Auto merge of #156552 - flip1995:clippy-subtree-update, r=Manishearth

Clippy subtree update

r? Manishearth 

`Cargo.lock` update due to patch version bump in `ui_test`.

One day early, as I won't have access to my laptop from tomorrow till Sunday

Author: bors

Cargo.lock

@@ -5948,9 +5948,9 @@ checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971"
 
 [[package]]
 name = "ui_test"
-version = "0.30.4"
+version = "0.30.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ada249620d81f010b9a1472b63a5077ac7c722dd0f4bacf6528b313d0b8c15d8"
+checksum = "980133b75aa9a95dc94feaf629d92d22c1172186f1fa1266b91f5b91414cf9a5"
 dependencies = [
  "annotate-snippets 0.11.5",
  "anyhow",

src/tools/clippy/CHANGELOG.md

@@ -6805,6 +6805,7 @@ Released 2018-09-13
 [`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
 [`inline_modules`]: https://rust-lang.github.io/rust-clippy/master/index.html#inline_modules
+[`inline_trait_bounds`]: https://rust-lang.github.io/rust-clippy/master/index.html#inline_trait_bounds
 [`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
@@ -6885,6 +6886,7 @@ Released 2018-09-13
 [`manual_c_str_literals`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_c_str_literals
 [`manual_checked_ops`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_checked_ops
 [`manual_clamp`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_clamp
+[`manual_clear`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_clear
 [`manual_contains`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_contains
 [`manual_dangling_ptr`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_dangling_ptr
 [`manual_div_ceil`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_div_ceil
@@ -7238,6 +7240,7 @@ Released 2018-09-13
 [`skip_while_next`]: https://rust-lang.github.io/rust-clippy/master/index.html#skip_while_next
 [`sliced_string_as_bytes`]: https://rust-lang.github.io/rust-clippy/master/index.html#sliced_string_as_bytes
 [`slow_vector_initialization`]: https://rust-lang.github.io/rust-clippy/master/index.html#slow_vector_initialization
+[`some_filter`]: https://rust-lang.github.io/rust-clippy/master/index.html#some_filter
 [`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

src/tools/clippy/Cargo.toml

@@ -34,7 +34,7 @@ anstream = "0.6.18"
 
 [dev-dependencies]
 cargo_metadata = "0.23"
-ui_test = "0.30.2"
+ui_test = "0.30.5"
 regex = "1.5.5"
 serde = { version = "1.0.145", features = ["derive"] }
 serde_json = "1.0.122"

src/tools/clippy/book/src/lints.md

@@ -14,9 +14,9 @@ The different lint groups were defined in the [Clippy 1.0 RFC].
 
 ## Correctness
 
-The `clippy::correctness` group is the only lint group in Clippy which lints are
+The `clippy::correctness` group is the only lint group in Clippy whose 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
+reason: if you see a `correctness` lint, it means that your code is outright
 wrong or useless, and you should try to fix it.
 
 Lints in this category are carefully picked and should be free of false

src/tools/clippy/clippy_lints/src/booleans.rs

@@ -297,8 +297,9 @@ impl<'v> Hir2Qmm<'_, '_, 'v> {
             return Err("contains never type".to_owned());
         }
 
+        let ctxt = e.span.ctxt();
         for (n, expr) in self.terminals.iter().enumerate() {
-            if eq_expr_value(self.cx, e, expr) {
+            if eq_expr_value(self.cx, ctxt, e, expr) {
                 #[expect(clippy::cast_possible_truncation)]
                 return Ok(Bool::Term(n as u8));
             }
@@ -307,8 +308,8 @@ impl<'v> Hir2Qmm<'_, '_, 'v> {
                 && 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)
+                && eq_expr_value(self.cx, ctxt, e_lhs, expr_lhs)
+                && eq_expr_value(self.cx, ctxt, e_rhs, expr_rhs)
             {
                 #[expect(clippy::cast_possible_truncation)]
                 return Ok(Bool::Not(Box::new(Bool::Term(n as u8))));

src/tools/clippy/clippy_lints/src/checked_conversions.rs

@@ -7,7 +7,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind, QPath, TyKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::impl_lint_pass;
-use rustc_span::Symbol;
+use rustc_span::{Symbol, SyntaxContext};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -62,7 +62,8 @@ impl LateLintPass<'_> for CheckedConversions {
                 },
                 _ => return,
             }
-            && !item.span.in_external_macro(cx.sess().source_map())
+            && let ctxt = item.span.ctxt()
+            && !ctxt.in_external_macro(cx.sess().source_map())
             && !is_in_const_context(cx)
             && let Some(cv) = match op2 {
                 // todo: check for case signed -> larger unsigned == only x >= 0
@@ -71,7 +72,7 @@ impl LateLintPass<'_> for CheckedConversions {
                     let upper_lower = |lt1, gt1, lt2, gt2| {
                         check_upper_bound(lt1, gt1)
                             .zip(check_lower_bound(lt2, gt2))
-                            .and_then(|(l, r)| l.combine(r, cx))
+                            .and_then(|(l, r)| l.combine(r, cx, ctxt))
                     };
                     upper_lower(lt1, gt1, lt2, gt2).or_else(|| upper_lower(lt2, gt2, lt1, gt1))
                 },
@@ -126,8 +127,8 @@ fn read_le_ge<'tcx>(
 
 impl<'a> Conversion<'a> {
     /// Combine multiple conversions if the are compatible
-    pub fn combine(self, other: Self, cx: &LateContext<'_>) -> Option<Conversion<'a>> {
-        if self.is_compatible(&other, cx) {
+    pub fn combine(self, other: Self, cx: &LateContext<'_>, ctxt: SyntaxContext) -> Option<Conversion<'a>> {
+        if self.is_compatible(&other, cx, ctxt) {
             // Prefer a Conversion that contains a type-constraint
             Some(if self.to_type.is_some() { self } else { other })
         } else {
@@ -137,9 +138,9 @@ impl<'a> Conversion<'a> {
 
     /// Checks if two conversions are compatible
     /// same type of conversion, same 'castee' and same 'to type'
-    pub fn is_compatible(&self, other: &Self, cx: &LateContext<'_>) -> bool {
+    pub fn is_compatible(&self, other: &Self, cx: &LateContext<'_>, ctxt: SyntaxContext) -> bool {
         (self.cvt == other.cvt)
-            && (SpanlessEq::new(cx).eq_expr(self.expr_to_cast, other.expr_to_cast))
+            && (SpanlessEq::new(cx).eq_expr(ctxt, self.expr_to_cast, other.expr_to_cast))
             && (self.has_compatible_to_type(other))
     }
 

src/tools/clippy/clippy_lints/src/comparison_chain.rs

@@ -6,7 +6,7 @@ use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
-use rustc_span::sym;
+use rustc_span::{SyntaxContext, sym};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -90,8 +90,10 @@ impl<'tcx> LateLintPass<'tcx> for ComparisonChain {
 
                 // Check that both sets of operands are equal
                 let mut spanless_eq = SpanlessEq::new(cx);
-                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);
+                let same_fixed_operands = spanless_eq.eq_expr(SyntaxContext::root(), lhs1, lhs2)
+                    && spanless_eq.eq_expr(SyntaxContext::root(), rhs1, rhs2);
+                let same_transposed_operands = spanless_eq.eq_expr(SyntaxContext::root(), lhs1, rhs2)
+                    && spanless_eq.eq_expr(SyntaxContext::root(), rhs1, lhs2);
 
                 if !same_fixed_operands && !same_transposed_operands {
                     return;

src/tools/clippy/clippy_lints/src/declared_lints.rs

@@ -232,6 +232,7 @@ pub static LINTS: &[&::declare_clippy_lint::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::inline_trait_bounds::INLINE_TRAIT_BOUNDS_INFO,
     crate::int_plus_one::INT_PLUS_ONE_INFO,
     crate::item_name_repetitions::ENUM_VARIANT_NAMES_INFO,
     crate::item_name_repetitions::MODULE_INCEPTION_INFO,
@@ -414,6 +415,7 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::methods::JOIN_ABSOLUTE_PATHS_INFO,
     crate::methods::LINES_FILTER_MAP_OK_INFO,
     crate::methods::MANUAL_C_STR_LITERALS_INFO,
+    crate::methods::MANUAL_CLEAR_INFO,
     crate::methods::MANUAL_CONTAINS_INFO,
     crate::methods::MANUAL_FILTER_MAP_INFO,
     crate::methods::MANUAL_FIND_MAP_INFO,
@@ -474,6 +476,7 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::methods::SINGLE_CHAR_ADD_STR_INFO,
     crate::methods::SKIP_WHILE_NEXT_INFO,
     crate::methods::SLICED_STRING_AS_BYTES_INFO,
+    crate::methods::SOME_FILTER_INFO,
     crate::methods::STABLE_SORT_PRIMITIVE_INFO,
     crate::methods::STR_SPLIT_AT_NEWLINE_INFO,
     crate::methods::STRING_EXTEND_CHARS_INFO,

src/tools/clippy/clippy_lints/src/entry.rs

@@ -498,11 +498,11 @@ impl<'tcx> Visitor<'tcx> for InsertSearcher<'_, 'tcx> {
         }
 
         match try_parse_insert(self.cx, expr) {
-            Some(insert_expr) if self.spanless_eq.eq_expr(self.map, insert_expr.map) => {
+            Some(insert_expr) if self.spanless_eq.eq_expr(self.ctxt, self.map, insert_expr.map) => {
                 self.visit_insert_expr_arguments(&insert_expr);
                 // Multiple inserts, inserts with a different key, and inserts from a macro can't use the entry api.
                 if self.is_map_used
-                    || !self.spanless_eq.eq_expr(self.key, insert_expr.key)
+                    || !self.spanless_eq.eq_expr(self.ctxt, self.key, insert_expr.key)
                     || expr.span.ctxt() != self.ctxt
                 {
                     self.can_use_entry = false;
@@ -521,10 +521,10 @@ impl<'tcx> Visitor<'tcx> for InsertSearcher<'_, 'tcx> {
                 self.visit_non_tail_expr(insert_expr.value);
                 self.is_single_insert = is_single_insert;
             },
-            _ if is_any_expr_in_map_used(self.cx, &mut self.spanless_eq, self.map, expr) => {
+            _ if is_any_expr_in_map_used(self.cx, &mut self.spanless_eq, self.ctxt, self.map, expr) => {
                 self.is_map_used = true;
             },
-            _ if self.spanless_eq.eq_expr(self.key, expr) => {
+            _ if self.spanless_eq.eq_expr(self.ctxt, self.key, expr) => {
                 self.is_key_used = true;
             },
             _ => match expr.kind {
@@ -600,11 +600,12 @@ impl<'tcx> Visitor<'tcx> for InsertSearcher<'_, 'tcx> {
 fn is_any_expr_in_map_used<'tcx>(
     cx: &LateContext<'tcx>,
     spanless_eq: &mut SpanlessEq<'_, 'tcx>,
+    ctxt: SyntaxContext,
     map: &'tcx Expr<'tcx>,
     expr: &'tcx Expr<'tcx>,
 ) -> bool {
     for_each_expr(cx, map, |e| {
-        if spanless_eq.eq_expr(e, expr) {
+        if spanless_eq.eq_expr(ctxt, e, expr) {
             return ControlFlow::Break(());
         }
         ControlFlow::Continue(())

src/tools/clippy/clippy_lints/src/floating_point_arithmetic/custom_abs.rs

@@ -14,11 +14,15 @@ use super::SUBOPTIMAL_FLOPS;
 /// test is positive or an expression which tests whether or not test
 /// is nonnegative.
 /// Used for check-custom-abs function below
-fn is_testing_positive(cx: &LateContext<'_>, expr: &Expr<'_>, test: &Expr<'_>) -> bool {
+fn is_testing_positive(cx: &LateContext<'_>, ctxt: SyntaxContext, 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, expr.span.ctxt()) && eq_expr_value(cx, left, test),
-            BinOpKind::Lt | BinOpKind::Le => is_zero(cx, left, expr.span.ctxt()) && eq_expr_value(cx, right, test),
+            BinOpKind::Gt | BinOpKind::Ge => {
+                is_zero(cx, right, expr.span.ctxt()) && eq_expr_value(cx, ctxt, left, test)
+            },
+            BinOpKind::Lt | BinOpKind::Le => {
+                is_zero(cx, left, expr.span.ctxt()) && eq_expr_value(cx, ctxt, right, test)
+            },
             _ => false,
         }
     } else {
@@ -27,11 +31,15 @@ fn is_testing_positive(cx: &LateContext<'_>, expr: &Expr<'_>, test: &Expr<'_>) -
 }
 
 /// See [`is_testing_positive`]
-fn is_testing_negative(cx: &LateContext<'_>, expr: &Expr<'_>, test: &Expr<'_>) -> bool {
+fn is_testing_negative(cx: &LateContext<'_>, ctxt: SyntaxContext, 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, expr.span.ctxt()) && eq_expr_value(cx, right, test),
-            BinOpKind::Lt | BinOpKind::Le => is_zero(cx, right, expr.span.ctxt()) && eq_expr_value(cx, left, test),
+            BinOpKind::Gt | BinOpKind::Ge => {
+                is_zero(cx, left, expr.span.ctxt()) && eq_expr_value(cx, ctxt, right, test)
+            },
+            BinOpKind::Lt | BinOpKind::Le => {
+                is_zero(cx, right, expr.span.ctxt()) && eq_expr_value(cx, ctxt, left, test)
+            },
             _ => false,
         }
     } else {
@@ -55,14 +63,21 @@ fn is_zero(cx: &LateContext<'_>, expr: &Expr<'_>, ctxt: SyntaxContext) -> bool {
 /// one of the two expressions
 /// If the two expressions are not negations of each other, then it
 /// returns None.
-fn are_negated<'a>(cx: &LateContext<'_>, expr1: &'a Expr<'a>, expr2: &'a Expr<'a>) -> Option<(bool, &'a Expr<'a>)> {
+fn are_negated<'a>(
+    cx: &LateContext<'_>,
+    ctxt: SyntaxContext,
+    expr1: &'a Expr<'a>,
+    expr2: &'a Expr<'a>,
+) -> Option<(bool, &'a Expr<'a>)> {
     if let ExprKind::Unary(UnOp::Neg, expr1_negated) = expr1.kind
-        && eq_expr_value(cx, expr1_negated, expr2)
+        && expr1_negated.span.ctxt() == ctxt
+        && eq_expr_value(cx, ctxt, expr1_negated, expr2)
     {
         return Some((false, expr2));
     }
     if let ExprKind::Unary(UnOp::Neg, expr2_negated) = expr2.kind
-        && eq_expr_value(cx, expr1, expr2_negated)
+        && expr2_negated.span.ctxt() == ctxt
+        && eq_expr_value(cx, ctxt, expr1, expr2_negated)
     {
         return Some((true, expr1));
     }
@@ -77,11 +92,12 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
     }) = 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 ctxt = expr.span.ctxt()
+        && let Some((if_expr_positive, body)) = are_negated(cx, ctxt, if_body_expr, else_body_expr)
     {
-        let sugg_positive_abs = if is_testing_positive(cx, cond, body) {
+        let sugg_positive_abs = if is_testing_positive(cx, ctxt, cond, body) {
             if_expr_positive
-        } else if is_testing_negative(cx, cond, body) {
+        } else if is_testing_negative(cx, ctxt, cond, body) {
             !if_expr_positive
         } else {
             return;