Introduce coerce_any_ref_to_any

Author: Ralith

CHANGELOG.md

@@ -5685,6 +5685,7 @@ Released 2018-09-13
 [`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
+[`coerce_any_ref_to_any`]: https://rust-lang.github.io/rust-clippy/master/index.html#coerce_any_ref_to_any
 [`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

clippy_lints/src/coerce_any_ref_to_any.rs

@@ -0,0 +1,108 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet;
+use clippy_utils::sym;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_middle::ty::{self, ExistentialPredicate, Ty};
+use rustc_session::declare_lint_pass;
+
+declare_clippy_lint! {
+    /// ### What it does
+    ///
+    /// Detects cases where a `&dyn Any` is constructed directly referencing a `Box<dyn Any>` or
+    /// other value that dereferences to `dyn Any`.
+    ///
+    /// ### Why is this bad?
+    ///
+    /// The intention is usually to borrow the `dyn Any` stored inside the value, rather than the
+    /// value itself.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let x: Box<dyn Any> = Box::new(());
+    /// let _: &dyn Any = &x;
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// let x: Box<dyn Any> = Box::new(());
+    /// let _: &dyn Any = &**x;
+    /// ```
+    #[clippy::version = "1.88.0"]
+    pub COERCE_ANY_REF_TO_ANY,
+    nursery,
+    "coercing reference to values containing `dyn Any` to `&dyn Any` is usually not intended"
+}
+declare_lint_pass!(CoerceAnyRefToAny => [COERCE_ANY_REF_TO_ANY]);
+
+impl<'tcx> LateLintPass<'tcx> for CoerceAnyRefToAny {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) {
+        // If this expression has an effective type of `&dyn Any` ...
+        {
+            let coerced_ty = cx.typeck_results().expr_ty_adjusted(e);
+
+            let ty::Ref(_, coerced_ref_ty, _) = *coerced_ty.kind() else {
+                return;
+            };
+            if !is_dyn_any(cx, coerced_ref_ty) {
+                return;
+            }
+        }
+
+        let expr_ty = cx.typeck_results().expr_ty(e);
+        let ty::Ref(_, expr_ref_ty, _) = *expr_ty.kind() else {
+            return;
+        };
+        // ... but only due to coercion ...
+        if is_dyn_any(cx, expr_ref_ty) {
+            return;
+        }
+        // ... and it also *derefs* to `dyn Any` ...
+        let Some((depth, target)) = clippy_utils::ty::deref_chain(cx, expr_ref_ty).enumerate().last() else {
+            return;
+        };
+        if !is_dyn_any(cx, target) {
+            return;
+        }
+
+        // ... that's probably not intended.
+        let (span, depth_offset) = match e.kind {
+            ExprKind::AddrOf(_, _, referent) => (referent.span, 1),
+            _ => (e.span, 0),
+        };
+        span_lint_and_sugg(
+            cx,
+            COERCE_ANY_REF_TO_ANY,
+            e.span,
+            format!(
+                "coercing `{}` to `&dyn Any` rather than dereferencing to the `dyn Any` inside",
+                expr_ty
+            ),
+            "consider dereferencing",
+            format!(
+                "&{}{}",
+                str::repeat("*", depth + 1 - depth_offset),
+                snippet(cx, span, "x")
+            ),
+            Applicability::MaybeIncorrect,
+        );
+    }
+}
+
+fn is_dyn_any(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
+    let ty::Dynamic(traits, ..) = ty.kind() else {
+        return false;
+    };
+    if traits.iter().all(|binder| {
+        let Some(predicate) = binder.no_bound_vars() else {
+            return false;
+        };
+        let ExistentialPredicate::Trait(t) = predicate else {
+            return false;
+        };
+        !cx.tcx.is_diagnostic_item(sym::Any, t.def_id)
+    }) {
+        return false;
+    }
+    true
+}

clippy_lints/src/declared_lints.rs

@@ -77,6 +77,7 @@ pub static LINTS: &[&crate::LintInfo] = &[
     crate::cfg_not_test::CFG_NOT_TEST_INFO,
     crate::checked_conversions::CHECKED_CONVERSIONS_INFO,
     crate::cloned_ref_to_slice_refs::CLONED_REF_TO_SLICE_REFS_INFO,
+    crate::coerce_any_ref_to_any::COERCE_ANY_REF_TO_ANY_INFO,
     crate::cognitive_complexity::COGNITIVE_COMPLEXITY_INFO,
     crate::collapsible_if::COLLAPSIBLE_ELSE_IF_INFO,
     crate::collapsible_if::COLLAPSIBLE_IF_INFO,

clippy_lints/src/lib.rs

@@ -95,6 +95,7 @@ mod casts;
 mod cfg_not_test;
 mod checked_conversions;
 mod cloned_ref_to_slice_refs;
+mod coerce_any_ref_to_any;
 mod cognitive_complexity;
 mod collapsible_if;
 mod collection_is_never_read;
@@ -944,5 +945,6 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(|_| Box::new(single_option_map::SingleOptionMap));
     store.register_late_pass(move |_| Box::new(redundant_test_prefix::RedundantTestPrefix));
     store.register_late_pass(|_| Box::new(cloned_ref_to_slice_refs::ClonedRefToSliceRefs::new(conf)));
+    store.register_late_pass(|_| Box::new(coerce_any_ref_to_any::CoerceAnyRefToAny));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }

rust-toolchain.toml

@@ -2,5 +2,5 @@
 # begin autogenerated nightly
 channel = "nightly-2025-05-01"
 # end autogenerated nightly
-components = ["cargo", "llvm-tools", "rust-src", "rust-std", "rustc", "rustc-dev", "rustfmt"]
+components = ["cargo", "llvm-tools", "rust-src", "rust-std", "rustc", "rustc-dev", "rustfmt", "rust-analyzer"]
 profile = "minimal"

tests/ui/coerce_any_ref_to_any.rs

@@ -0,0 +1,25 @@
+#![warn(clippy::coerce_any_ref_to_any)]
+
+use std::any::Any;
+
+fn main() {
+    let x: Box<dyn Any> = Box::new(());
+    let ref_x = &x;
+
+    f(&x);
+    //~^ coerce_any_ref_to_any
+
+    f(ref_x);
+    //~^ coerce_any_ref_to_any
+
+    let _: &dyn Any = &x;
+    //~^ coerce_any_ref_to_any
+
+    f(&42);
+    f(&Box::new(()));
+    f(&**ref_x);
+    f(&*x);
+    let _: &dyn Any = &*x;
+}
+
+fn f(_: &dyn Any) {}

tests/ui/coerce_any_ref_to_any.stderr

@@ -0,0 +1,23 @@
+error: coercing `&std::boxed::Box<dyn std::any::Any>` to `&dyn Any` rather than dereferencing the dyn Any inside it
+  --> tests/ui/coerce_any_ref_to_any.rs:9:7
+   |
+LL |     f(&x);
+   |       ^^
+   |
+   = note: `-D clippy::coerce-any-ref-to-any` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::coerce_any_ref_to_any)]`
+
+error: coercing `&std::boxed::Box<dyn std::any::Any>` to `&dyn Any` rather than dereferencing the dyn Any inside it
+  --> tests/ui/coerce_any_ref_to_any.rs:12:7
+   |
+LL |     f(ref_x);
+   |       ^^^^^
+
+error: coercing `&std::boxed::Box<dyn std::any::Any>` to `&dyn Any` rather than dereferencing the dyn Any inside it
+  --> tests/ui/coerce_any_ref_to_any.rs:15:23
+   |
+LL |     let _: &dyn Any = &x;
+   |                       ^^
+
+error: aborting due to 3 previous errors
+