Merge remote-tracking branch 'upstream/master' into rustup

Author: flip1995

CHANGELOG.md

@@ -6916,6 +6916,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_length_and_capacity`]: https://rust-lang.github.io/rust-clippy/master/index.html#same_length_and_capacity
 [`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

clippy_lints/src/assertions_on_constants.rs

@@ -3,6 +3,7 @@ use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::macros::{find_assert_args, root_macro_call_first_node};
 use clippy_utils::msrvs::Msrv;
+use clippy_utils::visitors::is_const_evaluatable;
 use clippy_utils::{is_inside_always_const_context, msrvs};
 use rustc_ast::LitKind;
 use rustc_hir::{Expr, ExprKind};
@@ -50,6 +51,7 @@ impl<'tcx> LateLintPass<'tcx> for AssertionsOnConstants {
                 _ => return,
             }
             && let Some((condition, _)) = find_assert_args(cx, e, macro_call.expn)
+            && is_const_evaluatable(cx, condition)
             && let Some((Constant::Bool(assert_val), const_src)) =
                 ConstEvalCtxt::new(cx).eval_with_source(condition, macro_call.span.ctxt())
             && let in_const_context = is_inside_always_const_context(cx.tcx, e.hir_id)

clippy_lints/src/booleans.rs

@@ -433,7 +433,7 @@ fn simplify_not(cx: &LateContext<'_>, curr_msrv: Msrv, expr: &Expr<'_>) -> Optio
         },
         ExprKind::MethodCall(path, receiver, args, _) => {
             let type_of_receiver = cx.typeck_results().expr_ty(receiver);
-            if !type_of_receiver.is_diag_item(cx, sym::Option) && !type_of_receiver.is_diag_item(cx, sym::Result) {
+            if !matches!(type_of_receiver.opt_diag_name(cx), Some(sym::Option | sym::Result)) {
                 return None;
             }
             METHODS_WITH_NEGATION

clippy_lints/src/casts/cast_precision_loss.rs

@@ -23,29 +23,21 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_from: Ty<'_>, ca
 
     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) {
-        // FIXME: handle 16 bits `usize` type
-        "32 or 64".to_owned()
+
+    let has_width = if is_isize_or_usize(cast_from) {
+        "can be up to 64 bits wide depending on the target architecture".to_owned()
     } else {
-        from_nbits.to_string()
+        format!("is {from_nbits} bits wide")
     };
 
     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
+            "casting `{cast_from}` to `{cast_to}` may cause a loss of precision \
+            (`{cast_from}` {has_width}, \
+             but `{cast_to}`'s mantissa is only {mantissa_nbits} bits wide)",
         ),
     );
 }

clippy_lints/src/casts/mod.rs

@@ -836,7 +836,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.93.0"]
     pub NEEDLESS_TYPE_CAST,
-    pedantic,
+    nursery,
     "binding defined with one type but always cast to another"
 }
 

clippy_lints/src/casts/needless_type_cast.rs

@@ -1,6 +1,8 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::sugg::Sugg;
 use clippy_utils::visitors::{Descend, for_each_expr, for_each_expr_without_closures};
 use core::ops::ControlFlow;
+use rustc_ast::ast::{LitFloatType, LitIntType, LitKind};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
@@ -14,6 +16,7 @@ use super::NEEDLESS_TYPE_CAST;
 struct BindingInfo<'a> {
     source_ty: Ty<'a>,
     ty_span: Span,
+    init: Option<&'a Expr<'a>>,
 }
 
 struct UsageInfo<'a> {
@@ -73,6 +76,7 @@ fn collect_binding_from_let<'a>(
                 BindingInfo {
                     source_ty: ty,
                     ty_span: ty_hir.span,
+                    init: Some(let_expr.init),
                 },
             );
         }
@@ -103,6 +107,7 @@ fn collect_binding_from_local<'a>(
                 BindingInfo {
                     source_ty: ty,
                     ty_span: ty_hir.span,
+                    init: let_stmt.init,
                 },
             );
         }
@@ -182,12 +187,7 @@ fn is_generic_res(cx: &LateContext<'_>, res: Res) -> bool {
             .iter()
             .any(|p| p.kind.is_ty_or_const())
     };
-    match res {
-        Res::Def(DefKind::Fn | DefKind::AssocFn, def_id) => has_type_params(def_id),
-        // Ctor → Variant → ADT: constructor's parent is variant, variant's parent is the ADT
-        Res::Def(DefKind::Ctor(..), def_id) => has_type_params(cx.tcx.parent(cx.tcx.parent(def_id))),
-        _ => false,
-    }
+    cx.tcx.res_generics_def_id(res).is_some_and(has_type_params)
 }
 
 fn is_cast_in_generic_context<'a>(cx: &LateContext<'a>, cast_expr: &Expr<'a>) -> bool {
@@ -234,6 +234,18 @@ fn is_cast_in_generic_context<'a>(cx: &LateContext<'a>, cast_expr: &Expr<'a>) ->
     }
 }
 
+fn can_coerce_to_target_type(expr: &Expr<'_>) -> bool {
+    match expr.kind {
+        ExprKind::Lit(lit) => matches!(
+            lit.node,
+            LitKind::Int(_, LitIntType::Unsuffixed) | LitKind::Float(_, LitFloatType::Unsuffixed)
+        ),
+        ExprKind::Unary(rustc_hir::UnOp::Neg, inner) => can_coerce_to_target_type(inner),
+        ExprKind::Binary(_, lhs, rhs) => can_coerce_to_target_type(lhs) && can_coerce_to_target_type(rhs),
+        _ => false,
+    }
+}
+
 fn check_binding_usages<'a>(cx: &LateContext<'a>, body: &Body<'a>, hir_id: HirId, binding_info: &BindingInfo<'a>) {
     let mut usages = Vec::new();
 
@@ -274,16 +286,48 @@ fn check_binding_usages<'a>(cx: &LateContext<'a>, body: &Body<'a>, hir_id: HirId
         return;
     };
 
-    span_lint_and_sugg(
+    // Don't lint if there's exactly one use and the initializer cannot be coerced to the
+    // target type (i.e., would require an explicit cast). In such cases, the fix would add
+    // a cast to the initializer rather than eliminating one - the cast isn't truly "needless."
+    // See: https://github.com/rust-lang/rust-clippy/issues/16240
+    if usages.len() == 1
+        && binding_info
+            .init
+            .is_some_and(|init| !can_coerce_to_target_type(init) && !init.span.from_expansion())
+    {
+        return;
+    }
+
+    span_lint_and_then(
         cx,
         NEEDLESS_TYPE_CAST,
         binding_info.ty_span,
         format!(
             "this binding is defined as `{}` but is always cast to `{}`",
             binding_info.source_ty, first_target
         ),
-        "consider defining it as",
-        first_target.to_string(),
-        Applicability::MaybeIncorrect,
+        |diag| {
+            if let Some(init) = binding_info
+                .init
+                .filter(|i| !can_coerce_to_target_type(i) && !i.span.from_expansion())
+            {
+                let sugg = Sugg::hir(cx, init, "..").as_ty(first_target);
+                diag.multipart_suggestion(
+                    format!("consider defining it as `{first_target}` and casting the initializer"),
+                    vec![
+                        (binding_info.ty_span, first_target.to_string()),
+                        (init.span, sugg.to_string()),
+                    ],
+                    Applicability::MachineApplicable,
+                );
+            } else {
+                diag.span_suggestion(
+                    binding_info.ty_span,
+                    "consider defining it as",
+                    first_target.to_string(),
+                    Applicability::MachineApplicable,
+                );
+            }
+        },
     );
 }

clippy_lints/src/casts/ref_as_ptr.rs

@@ -1,9 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
-use clippy_utils::{ExprUseNode, expr_use_ctxt, std_or_core};
+use clippy_utils::{ExprUseNode, expr_use_ctxt, is_expr_temporary_value, std_or_core};
 use rustc_errors::Applicability;
-use rustc_hir::{Expr, Mutability, Ty, TyKind};
+use rustc_hir::{Expr, ExprKind, Mutability, Ty, TyKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty;
 
@@ -23,10 +23,18 @@ pub(super) fn check<'tcx>(
     if matches!(cast_from.kind(), ty::Ref(..))
         && let ty::RawPtr(_, to_mutbl) = cast_to.kind()
         && let use_cx = expr_use_ctxt(cx, expr)
-        // TODO: only block the lint if `cast_expr` is a temporary
-        && !matches!(use_cx.use_node(cx), ExprUseNode::LetStmt(_) | ExprUseNode::ConstStatic(_))
         && let Some(std_or_core) = std_or_core(cx)
     {
+        if let ExprKind::AddrOf(_, _, addr_inner) = cast_expr.kind
+            && is_expr_temporary_value(cx, addr_inner)
+            && matches!(
+                use_cx.use_node(cx),
+                ExprUseNode::LetStmt(_) | ExprUseNode::ConstStatic(_)
+            )
+        {
+            return;
+        }
+
         let fn_name = match to_mutbl {
             Mutability::Not => "from_ref",
             Mutability::Mut => "from_mut",

clippy_lints/src/collapsible_if.rs

@@ -76,7 +76,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.51.0"]
     pub COLLAPSIBLE_ELSE_IF,
-    style,
+    pedantic,
     "nested `else`-`if` expressions that can be collapsed (e.g., `else { if x { ... } }`)"
 }
 
@@ -267,6 +267,9 @@ impl LateLintPass<'_> for CollapsibleIf {
             && !expr.span.from_expansion()
         {
             if let Some(else_) = else_
+                // Short circuit if both `if` branches contain only a single `if {..} else {}`, as
+                // collapsing such blocks can lead to less readable code (#4971)
+                && !(single_inner_if_else(then) && single_inner_if_else(else_))
                 && let ExprKind::Block(else_, None) = else_.kind
             {
                 self.check_collapsible_else_if(cx, then.span, else_);
@@ -280,6 +283,19 @@ impl LateLintPass<'_> for CollapsibleIf {
     }
 }
 
+/// Returns true if `expr` is a block that contains only one `if {..} else {}` statement
+fn single_inner_if_else(expr: &Expr<'_>) -> bool {
+    if let ExprKind::Block(block, None) = expr.kind
+        && let Some(inner_expr) = expr_block(block)
+        && let ExprKind::If(_, _, else_) = inner_expr.kind
+        && else_.is_some()
+    {
+        true
+    } else {
+        false
+    }
+}
+
 /// If `block` is a block with either one expression or a statement containing an expression,
 /// return the expression. We don't peel blocks recursively, as extra blocks might be intentional.
 fn expr_block<'tcx>(block: &Block<'tcx>) -> Option<&'tcx Expr<'tcx>> {

clippy_lints/src/declared_lints.rs

@@ -667,6 +667,7 @@ pub static LINTS: &[&::declare_clippy_lint::LintInfo] = &[
     crate::returns::LET_AND_RETURN_INFO,
     crate::returns::NEEDLESS_RETURN_INFO,
     crate::returns::NEEDLESS_RETURN_WITH_QUESTION_MARK_INFO,
+    crate::same_length_and_capacity::SAME_LENGTH_AND_CAPACITY_INFO,
     crate::same_name_method::SAME_NAME_METHOD_INFO,
     crate::self_named_constructors::SELF_NAMED_CONSTRUCTORS_INFO,
     crate::semicolon_block::SEMICOLON_INSIDE_BLOCK_INFO,

clippy_lints/src/disallowed_methods.rs

@@ -88,6 +88,9 @@ impl_lint_pass!(DisallowedMethods => [DISALLOWED_METHODS]);
 
 impl<'tcx> LateLintPass<'tcx> for DisallowedMethods {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
+        if expr.span.desugaring_kind().is_some() {
+            return;
+        }
         let (id, span) = match &expr.kind {
             ExprKind::Path(path) if let Res::Def(_, id) = cx.qpath_res(path, expr.hir_id) => (id, expr.span),
             ExprKind::MethodCall(name, ..) if let Some(id) = cx.typeck_results().type_dependent_def_id(expr.hir_id) => {