[type_id_on_box]: lint of Any subtraits

clippy_lints/src/methods/type_id_on_box.rs

@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 use crate::methods::TYPE_ID_ON_BOX;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::snippet;
@@ -5,17 +7,37 @@ use rustc_errors::Applicability;
 use rustc_hir::Expr;
 use rustc_lint::LateContext;
 use rustc_middle::ty::adjustment::{Adjust, Adjustment};
+use rustc_middle::ty::print::with_forced_trimmed_paths;
 use rustc_middle::ty::{self, ExistentialPredicate, Ty};
 use rustc_span::{sym, Span};
 
-fn is_dyn_any(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
+/// Checks if a [`Ty`] is a `dyn Any` or a `dyn Trait` where `Trait: Any`
+/// and returns the name of the trait object.
+fn is_dyn_any(cx: &LateContext<'_>, ty: Ty<'_>) -> Option<Cow<'static, str>> {
     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,
+        preds.iter().find_map(|p| match p.skip_binder() {
+            ExistentialPredicate::Trait(tr) => {
+                if cx.tcx.is_diagnostic_item(sym::Any, tr.def_id) {
+                    Some(Cow::Borrowed("Any"))
+                } else if cx
+                    .tcx
+                    .super_predicates_of(tr.def_id)
+                    .predicates
+                    .iter()
+                    .any(|(clause, _)| {
+                        matches!(clause.kind().skip_binder(), ty::ClauseKind::Trait(super_tr)
+                            if cx.tcx.is_diagnostic_item(sym::Any, super_tr.def_id()))
+                    })
+                {
+                    Some(Cow::Owned(with_forced_trimmed_paths!(cx.tcx.def_path_str(tr.def_id))))
+                } else {
+                    None
+                }
+            },
+            _ => None,
         })
     } else {
-        false
+        None
     }
 }
 
@@ -26,13 +48,13 @@ pub(super) fn check(cx: &LateContext<'_>, receiver: &Expr<'_>, call_span: Span)
         && let ty::Ref(_, ty, _) = recv_ty.kind()
         && let ty::Adt(adt, args) = ty.kind()
         && adt.is_box()
-        && is_dyn_any(cx, args.type_at(0))
+        && let Some(trait_path) = is_dyn_any(cx, args.type_at(0))
     {
         span_lint_and_then(
             cx,
             TYPE_ID_ON_BOX,
             call_span,
-            "calling `.type_id()` on a `Box<dyn Any>`",
+            &format!("calling `.type_id()` on `Box<dyn {trait_path}>`"),
             |diag| {
                 let derefs = recv_adjusts
                     .iter()
@@ -43,13 +65,13 @@ pub(super) fn check(cx: &LateContext<'_>, receiver: &Expr<'_>, call_span: Span)
                 sugg += &snippet(cx, receiver.span, "<expr>");
 
                 diag.note(
-                    "this returns the type id of the literal type `Box<dyn Any>` instead of the \
+                    "this returns the type id of the literal type `Box<_>` 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(format!(
+                    "if this is intentional, use `TypeId::of::<Box<dyn {trait_path}>>()` instead, \
+                    which makes it more clear"
+                ))
                 .span_suggestion(
                     receiver.span,
                     "consider dereferencing first",