Clippy subtree update

src/tools/clippy/CHANGELOG.md

@@ -6797,9 +6797,11 @@ Released 2018-09-13
 [`manual_midpoint`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_midpoint
 [`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_noop_waker`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_noop_waker
 [`manual_ok_err`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_ok_err
 [`manual_ok_or`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_ok_or
 [`manual_option_as_slice`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_option_as_slice
+[`manual_option_zip`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_option_zip
 [`manual_pattern_char_comparison`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_pattern_char_comparison
 [`manual_pop_if`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_pop_if
 [`manual_range_contains`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_range_contains

src/tools/clippy/clippy_config/src/lib.rs

@@ -7,7 +7,6 @@
     unused_qualifications
 )]
 #![allow(clippy::must_use_candidate, clippy::missing_panics_doc)]
-#![deny(clippy::derive_deserialize_allowing_unknown)]
 
 extern crate rustc_data_structures;
 extern crate rustc_errors;

src/tools/clippy/clippy_dev/src/lib.rs

@@ -1,7 +1,6 @@
 #![feature(
     exit_status_error,
     new_range,
-    new_range_api,
     os_str_slice,
     os_string_truncate,
     pattern,

src/tools/clippy/clippy_dev/src/new_lint.rs

@@ -275,8 +275,8 @@ fn get_lint_file_contents(lint: &LintData<'_>, enable_msrv: bool) -> String {
         let _: fmt::Result = writedoc!(
             result,
             r"
-            use clippy_utils::msrvs::{{self, {msrv_ty}}};
             use clippy_config::Conf;
+            use clippy_utils::msrvs::{{self, {msrv_ty}}};
             {pass_import}
             use rustc_lint::{{{context_import}, {pass_type}}};
             use rustc_session::impl_lint_pass;
@@ -319,7 +319,7 @@ fn get_lint_file_contents(lint: &LintData<'_>, enable_msrv: bool) -> String {
 
             impl {pass_type}{pass_lifetimes} for {name_camel} {{{extract_msrv}}}
 
-            // TODO: Add MSRV level to `clippy_config/src/msrvs.rs` if needed.
+            // TODO: Add MSRV level to `clippy_utils/src/msrvs.rs` if needed.
             // TODO: Update msrv config comment in `clippy_config/src/conf.rs`
         "
         );

src/tools/clippy/clippy_lints/src/casts/unnecessary_cast.rs

@@ -1,7 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::numeric_literal::NumericLiteral;
 use clippy_utils::res::MaybeResPath as _;
-use clippy_utils::source::{SpanRangeExt, snippet_opt};
+use clippy_utils::source::{SpanRangeExt, snippet, snippet_with_applicability};
+use clippy_utils::sugg::has_enclosing_paren;
 use clippy_utils::visitors::{Visitable, for_each_expr_without_closures};
 use clippy_utils::{get_parent_expr, is_hir_ty_cfg_dependant, is_ty_alias, sym};
 use rustc_ast::{LitFloatType, LitIntType, LitKind};
@@ -24,7 +25,8 @@ 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();
+    let mut app = Applicability::MachineApplicable;
+    let cast_str = snippet_with_applicability(cx, cast_expr.span, "_", &mut app);
 
     if let ty::RawPtr(..) = cast_from.kind()
         // check both mutability and type are the same
@@ -47,16 +49,23 @@ pub(super) fn check<'tcx>(
             _ => {},
         }
 
-        span_lint_and_sugg(
+        // Preserve parentheses around `expr` in case of cascaded casts
+        let surrounding =
+            if matches!(cast_expr.kind, ExprKind::Cast(..)) && has_enclosing_paren(snippet(cx, expr.span, "")) {
+                MaybeParenOrBlock::Paren
+            } else {
+                MaybeParenOrBlock::Nothing
+            };
+
+        emit_lint(
             cx,
-            UNNECESSARY_CAST,
-            expr.span,
+            expr,
             format!(
                 "casting raw pointers to the same type and constness is unnecessary (`{cast_from}` -> `{cast_to}`)"
             ),
-            "try",
-            cast_str.clone(),
-            Applicability::MaybeIncorrect,
+            &cast_str,
+            surrounding,
+            app.max(Applicability::MaybeIncorrect),
         );
     }
 
@@ -143,12 +152,6 @@ pub(super) fn check<'tcx>(
     }
 
     if cast_from.kind() == cast_to.kind() && !expr.span.in_external_macro(cx.sess().source_map()) {
-        enum MaybeParenOrBlock {
-            Paren,
-            Block,
-            Nothing,
-        }
-
         fn is_borrow_expr(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
             matches!(expr.kind, ExprKind::AddrOf(..))
                 || cx
@@ -188,18 +191,13 @@ pub(super) fn check<'tcx>(
             _ => MaybeParenOrBlock::Nothing,
         };
 
-        span_lint_and_sugg(
+        emit_lint(
             cx,
-            UNNECESSARY_CAST,
-            expr.span,
+            expr,
             format!("casting to the same type is unnecessary (`{cast_from}` -> `{cast_to}`)"),
-            "try",
-            match surrounding {
-                MaybeParenOrBlock::Paren => format!("({cast_str})"),
-                MaybeParenOrBlock::Block => format!("{{ {cast_str} }}"),
-                MaybeParenOrBlock::Nothing => cast_str,
-            },
-            Applicability::MachineApplicable,
+            &cast_str,
+            surrounding,
+            app,
         );
         return true;
     }
@@ -312,3 +310,33 @@ fn is_cast_from_ty_alias<'tcx>(cx: &LateContext<'tcx>, expr: impl Visitable<'tcx
     })
     .is_some()
 }
+
+#[derive(Clone, Copy)]
+enum MaybeParenOrBlock {
+    Paren,
+    Block,
+    Nothing,
+}
+
+fn emit_lint(
+    cx: &LateContext<'_>,
+    expr: &Expr<'_>,
+    msg: String,
+    sugg: &str,
+    surrounding: MaybeParenOrBlock,
+    applicability: Applicability,
+) {
+    span_lint_and_sugg(
+        cx,
+        UNNECESSARY_CAST,
+        expr.span,
+        msg,
+        "try",
+        match surrounding {
+            MaybeParenOrBlock::Paren => format!("({sugg})"),
+            MaybeParenOrBlock::Block => format!("{{ {sugg} }}"),
+            MaybeParenOrBlock::Nothing => sugg.to_string(),
+        },
+        applicability,
+    );
+}

src/tools/clippy/clippy_lints/src/collapsible_if.rs

@@ -2,7 +2,7 @@ use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::msrvs::Msrv;
 use clippy_utils::source::{HasSession, IntoSpan as _, SpanRangeExt, snippet, snippet_block_with_applicability};
-use clippy_utils::{can_use_if_let_chains, span_contains_non_whitespace, sym, tokenize_with_text};
+use clippy_utils::{can_use_if_let_chains, span_contains_cfg, span_contains_non_whitespace, sym, tokenize_with_text};
 use rustc_ast::BinOpKind;
 use rustc_errors::Applicability;
 use rustc_hir::attrs::{AttributeKind, LintAttributeKind};
@@ -170,6 +170,11 @@ impl CollapsibleIf {
             && self.eligible_condition(cx, check_inner)
             && expr.span.eq_ctxt(inner.span)
             && self.check_significant_tokens_and_expect_attrs(cx, then, inner, sym::collapsible_if)
+            && let then_closing_bracket = {
+                let end = then.span.shrink_to_hi();
+                end.with_lo(end.lo() - BytePos(1))
+            }
+            && !span_contains_cfg(cx, inner.span.between(then_closing_bracket))
         {
             span_lint_hir_and_then(
                 cx,
@@ -179,12 +184,7 @@ impl CollapsibleIf {
                 "this `if` statement can be collapsed",
                 |diag| {
                     let then_open_bracket = then.span.split_at(1).0.with_leading_whitespace(cx).into_span();
-                    let then_closing_bracket = {
-                        let end = then.span.shrink_to_hi();
-                        end.with_lo(end.lo() - BytePos(1))
-                            .with_leading_whitespace(cx)
-                            .into_span()
-                    };
+                    let then_closing_bracket = then_closing_bracket.with_leading_whitespace(cx).into_span();
                     let (paren_start, inner_if_span, paren_end) = peel_parens(cx, inner.span);
                     let inner_if = inner_if_span.split_at(2).0;
                     let mut sugg = vec![
@@ -238,12 +238,10 @@ impl CollapsibleIf {
                 !span_contains_non_whitespace(cx, span, self.lint_commented_code)
             },
 
-            [
-                Attribute::Parsed(AttributeKind::LintAttributes(sub_attrs)),
-            ] => {
+            [Attribute::Parsed(AttributeKind::LintAttributes(sub_attrs))] => {
                 sub_attrs
                     .into_iter()
-                    .filter(|attr|attr.kind == LintAttributeKind::Expect)
+                    .filter(|attr| attr.kind == LintAttributeKind::Expect)
                     .flat_map(|attr| attr.lint_instances.iter().map(|group| (attr.attr_span, group)))
                     .filter(|(_, lint_id)| {
                         lint_id.tool_is_named(sym::clippy)

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

@@ -311,6 +311,7 @@ pub static LINTS: &[&::declare_clippy_lint::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_noop_waker::MANUAL_NOOP_WAKER_INFO,
     crate::manual_option_as_slice::MANUAL_OPTION_AS_SLICE_INFO,
     crate::manual_pop_if::MANUAL_POP_IF_INFO,
     crate::manual_range_patterns::MANUAL_RANGE_PATTERNS_INFO,
@@ -418,6 +419,7 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::methods::MANUAL_IS_VARIANT_AND_INFO,
     crate::methods::MANUAL_NEXT_BACK_INFO,
     crate::methods::MANUAL_OK_OR_INFO,
+    crate::methods::MANUAL_OPTION_ZIP_INFO,
     crate::methods::MANUAL_REPEAT_N_INFO,
     crate::methods::MANUAL_SATURATING_ARITHMETIC_INFO,
     crate::methods::MANUAL_SPLIT_ONCE_INFO,

src/tools/clippy/clippy_lints/src/lib.rs

@@ -209,6 +209,7 @@ mod manual_is_power_of_two;
 mod manual_let_else;
 mod manual_main_separator_str;
 mod manual_non_exhaustive;
+mod manual_noop_waker;
 mod manual_option_as_slice;
 mod manual_pop_if;
 mod manual_range_patterns;
@@ -864,7 +865,8 @@ pub fn register_lint_passes(store: &mut rustc_lint::LintStore, conf: &'static Co
         Box::new(move |tcx| Box::new(duration_suboptimal_units::DurationSuboptimalUnits::new(tcx, conf))),
         Box::new(move |_| Box::new(manual_take::ManualTake::new(conf))),
         Box::new(|_| Box::new(manual_checked_ops::ManualCheckedOps)),
-        Box::new(move |_| Box::new(manual_pop_if::ManualPopIf::new(conf))),
+        Box::new(move |tcx| Box::new(manual_pop_if::ManualPopIf::new(tcx, conf))),
+        Box::new(|_| Box::new(manual_noop_waker::ManualNoopWaker)),
         // add late passes here, used by `cargo dev new_lint`
     ];
     store.late_passes.extend(late_lints);

src/tools/clippy/clippy_lints/src/loops/explicit_counter_loop.rs

@@ -2,6 +2,7 @@ use std::borrow::Cow;
 
 use super::{EXPLICIT_COUNTER_LOOP, IncrementVisitor, InitializeVisitor, make_iterator_snippet};
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::higher::Range;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::{EMPTY, Sugg};
 use clippy_utils::{get_enclosing_block, is_integer_const, is_integer_literal_untyped};
@@ -83,6 +84,26 @@ pub(super) fn check<'tcx>(
                     snippet
                 });
 
+                // If the loop variable is unused and the range is `0..n`, suggest `(init..).take(n)`.
+                if pat_snippet == "_"
+                    && let Some(range) = Range::hir(cx, arg)
+                    && range.limits == RangeLimits::HalfOpen
+                    && range.start.is_some_and(|start| is_integer_const(cx, start, 0))
+                    && let Some(end) = range.end
+                {
+                    let end = snippet_with_applicability(cx, end.span, "..", &mut applicability);
+                    diag.span_suggestion(
+                        span,
+                        "consider using",
+                        format!(
+                            "{loop_label}for {name} in ({}).take({end})",
+                            initializer.range(&EMPTY, RangeLimits::HalfOpen)
+                        ),
+                        applicability,
+                    );
+                    return;
+                }
+
                 diag.span_suggestion(
                     span,
                     "consider using",

src/tools/clippy/clippy_lints/src/loops/manual_memcpy.rs

@@ -385,8 +385,8 @@ fn get_details_from_idx<'tcx>(
         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))));
+                    .zip(get_offset(cx, rhs, starts))
+                    .or_else(|| get_start(rhs, starts).zip(get_offset(cx, lhs, starts)));
 
                 offset_opt.map(|(s, o)| (s, Offset::positive(o)))
             },

src/tools/clippy/clippy_lints/src/manual_is_ascii_check.rs

@@ -91,6 +91,13 @@ enum CharRange {
 
 impl<'tcx> LateLintPass<'tcx> for ManualIsAsciiCheck {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if !matches!(
+            expr.kind,
+            ExprKind::Match(_, [_, ..], _) | ExprKind::MethodCall(_, _, [_], _)
+        ) {
+            return;
+        }
+
         if !self.msrv.meets(cx, msrvs::IS_ASCII_DIGIT) {
             return;
         }
@@ -99,8 +106,8 @@ impl<'tcx> LateLintPass<'tcx> for ManualIsAsciiCheck {
             return;
         }
 
-        let (arg, span, range) = if let Some(macro_call) = matching_root_macro_call(cx, expr.span, sym::matches_macro)
-            && let ExprKind::Match(recv, [arm, ..], _) = expr.kind
+        let (arg, span, range) = if let ExprKind::Match(recv, [arm, ..], _) = expr.kind
+            && let Some(macro_call) = matching_root_macro_call(cx, expr.span, sym::matches_macro)
         {
             let recv = peel_ref_operators(cx, recv);
             let range = check_pat(&arm.pat.kind);

src/tools/clippy/clippy_lints/src/manual_noop_waker.rs

@@ -0,0 +1,71 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::{is_empty_block, sym};
+use rustc_hir::{ImplItemKind, Item, ItemKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::declare_lint_pass;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for manual implementations of `std::task::Wake` that are empty.
+    ///
+    /// ### Why is this bad?
+    /// `Waker::noop()` provides a more performant and cleaner way to create a
+    /// waker that does nothing, avoiding unnecessary `Arc` allocations and
+    /// reference count increments.
+    ///
+    /// ### Example
+    /// ```rust
+    /// # use std::sync::Arc;
+    /// # use std::task::Wake;
+    /// struct MyWaker;
+    /// impl Wake for MyWaker {
+    ///     fn wake(self: Arc<Self>) {}
+    ///     fn wake_by_ref(self: &Arc<Self>) {}
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```rust
+    /// use std::task::Waker;
+    /// let waker = Waker::noop();
+    /// ```
+    #[clippy::version = "1.96.0"]
+    pub MANUAL_NOOP_WAKER,
+    complexity,
+    "manual implementations of noop wakers can be simplified using Waker::noop()"
+}
+
+declare_lint_pass!(ManualNoopWaker => [MANUAL_NOOP_WAKER]);
+
+impl<'tcx> LateLintPass<'tcx> for ManualNoopWaker {
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
+        if let ItemKind::Impl(imp) = item.kind
+            && let Some(trait_ref) = imp.of_trait
+            && let Some(trait_id) = trait_ref.trait_ref.trait_def_id()
+            && cx.tcx.is_diagnostic_item(sym::Wake, trait_id)
+        {
+            for impl_item_ref in imp.items {
+                let impl_item = cx
+                    .tcx
+                    .hir_node_by_def_id(impl_item_ref.owner_id.def_id)
+                    .expect_impl_item();
+
+                if let ImplItemKind::Fn(_, body_id) = &impl_item.kind {
+                    let body = cx.tcx.hir_body(*body_id);
+                    if !is_empty_block(body.value) {
+                        return;
+                    }
+                }
+            }
+
+            span_lint_and_help(
+                cx,
+                MANUAL_NOOP_WAKER,
+                trait_ref.trait_ref.path.span,
+                "manual implementation of a no-op waker",
+                None,
+                "use `std::task::Waker::noop()` instead",
+            );
+        }
+    }
+}