Create unnecessary_send_constraint lint for &(dyn ... + Send)

compiler/rustc_lint/messages.ftl

@@ -192,6 +192,16 @@ lint_redundant_semicolons =
         *[false] this semicolon
     }
 
+lint_useless_send_constraint =
+    constraining a reference to `Send` is useless, consider {$only_trait ->
+        [true] replacing it with `Any`
+        *[false] removing it
+    }
+    .suggestion = {$only_trait ->
+        [true] replace this with `Any`
+        *[false] remove this
+    }
+
 lint_drop_trait_constraints =
     bounds on `{$predicate}` are most likely incorrect, consider instead using `{$needs_drop}` to detect whether a type can be trivially dropped
 

compiler/rustc_lint/src/builtin.rs

@@ -21,6 +21,7 @@
 //! `late_lint_methods!` invocation in `lib.rs`.
 
 use crate::fluent_generated as fluent;
+use crate::lints::UselessSendConstraintDiag;
 use crate::{
     errors::BuiltinEllipsisInclusiveRangePatterns,
     lints::{

compiler/rustc_lint/src/lib.rs

@@ -242,6 +242,7 @@ late_lint_methods!(
             OpaqueHiddenInferredBound: OpaqueHiddenInferredBound,
             MultipleSupertraitUpcastable: MultipleSupertraitUpcastable,
             MapUnitFn: MapUnitFn,
+            UselessSendConstraint: UselessSendConstraint,
         ]
     ]
 );

compiler/rustc_lint/src/lints.rs

@@ -1168,6 +1168,15 @@ pub struct RedundantSemicolonsDiag {
     pub suggestion: Span,
 }
 
+// lint_useless_send_constraint.rs
+#[derive(LintDiagnostic)]
+#[diag(lint_useless_send_constraint)]
+pub struct UselessSendConstraintDiag {
+    pub only_trait: bool,
+    #[suggestion(code = "", applicability = "maybe-incorrect")]
+    pub suggestion: Span,
+}
+
 // traits.rs
 pub struct DropTraitConstraintsDiag<'a> {
     pub predicate: Predicate<'a>,

compiler/rustc_lint/src/useless_send_constraint.rs

@@ -0,0 +1,44 @@
+declare_lint! {
+    /// The `lint_useless_send_constraint` lints useless constraint of references to `Send`.
+    ///
+    /// ### Example
+    ///
+    /// ```rust,compile_fail
+    /// fn foo(_: &(dyn Any + Send>) {}
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// References cannot be sent across threads, so constraining them to `Send` is useless.
+    pub USELESS_SEND_CONSTRAINT,
+    Warn,
+    "constraining a reference to `Send` is useless, consider removing it"
+}
+
+declare_lint_pass!(UselessSendConstraint => [USELESS_SEND_CONSTRAINT]);
+
+impl<'tcx> LateLintPass<'tcx> for UselessSendConstraint {
+    fn check_ty(&mut self, cx: &LateContext<'tcx>, ty: &'tcx hir::Ty<'tcx>) {
+        let hir::TyKind::Ref(_, hir::MutTy { ty, mutbl: _mutbl }) = ty.kind else { return; };
+
+        let hir::TyKind::TraitObject(bounds, _, _) = ty.kind else { return; };
+
+        let send = cx.tcx.get_diagnostic_item(sym::Send);
+
+        let send_bound = bounds.iter().find(|b| b.trait_ref.trait_def_id() == send);
+
+        if let Some(send_bound) = send_bound {
+            let only_trait = bounds.len() == 1;
+
+            // We have multiple bounds. one is `Send`
+            // Suggest removing it
+            cx.emit_spanned_lint(
+                USELESS_SEND_CONSTRAINT,
+                send_bound.span,
+                UselessSendConstraintDiag { only_trait, suggestion: send_bound.span },
+            )
+        }
+    }
+}

library/core/src/cell.rs

@@ -2246,6 +2246,7 @@ impl<T: CoerceUnsized<U>, U> CoerceUnsized<SyncUnsafeCell<U>> for SyncUnsafeCell
 impl<T: DispatchFromDyn<U>, U> DispatchFromDyn<SyncUnsafeCell<U>> for SyncUnsafeCell<T> {}
 
 #[allow(unused)]
+#[allow(useless_send_constraint)]
 fn assert_coerce_unsized(
     a: UnsafeCell<&i32>,
     b: SyncUnsafeCell<&i32>,

tests/ui/lint/useless-send-constraint/useless-send-constraint.rs

@@ -0,0 +1,10 @@
+// check-pass
+#![warn(useless_send_constraint)]
+
+use std::any::Any;
+
+fn main() {}
+
+fn foo(_a: &(dyn Any + Send + Send)) {
+
+}