Uplifts needless-maybe-sized lint from clippy

- Copies the lint and test (+ stderr) from clippy into rustc_lint/src and
  tests/ui/lint respectively.
- Makes necessary changes to uplifted lint to work correctly in
  rustc.
- Removes needless `?Sized` bounds from 3 files as detected and suggested
  by the lint.

Author: CrooseGit

compiler/rustc_lint/src/lib.rs

@@ -60,6 +60,7 @@ mod lints;
 mod macro_expr_fragment_specifier_2024_migration;
 mod map_unit_fn;
 mod multiple_supertrait_upcastable;
+mod needless_maybe_sized;
 mod non_ascii_idents;
 mod non_fmt_panic;
 mod non_local_def;
@@ -101,6 +102,7 @@ use lifetime_syntax::*;
 use macro_expr_fragment_specifier_2024_migration::*;
 use map_unit_fn::*;
 use multiple_supertrait_upcastable::*;
+use needless_maybe_sized::NeedlessMaybeSized;
 use non_ascii_idents::*;
 use non_fmt_panic::NonPanicFmt;
 use non_local_def::*;
@@ -247,6 +249,7 @@ late_lint_methods!(
             UnqualifiedLocalImports: UnqualifiedLocalImports,
             CheckTransmutes: CheckTransmutes,
             LifetimeSyntax: LifetimeSyntax,
+            NeedlessMaybeSized: NeedlessMaybeSized,
         ]
     ]
 );

compiler/rustc_lint/src/needless_maybe_sized.rs

@@ -0,0 +1,157 @@
+use rustc_errors::Applicability;
+use rustc_hir::def_id::{DefId, DefIdMap};
+use rustc_hir::{
+    BoundPolarity, GenericBound, Generics, PolyTraitRef, TraitBoundModifiers, WherePredicateKind,
+};
+use rustc_middle::ty::{ClauseKind, PredicatePolarity};
+use rustc_session::{declare_lint, declare_lint_pass};
+use rustc_span::symbol::Ident;
+
+use crate::{LateContext, LateLintPass, LintContext};
+
+declare_lint! {
+    /// The `needless_maybe_sized` lint detects `?Sized` bounds applied to type parameters that cannot be unsized.
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// // `T` cannot be unsized because `Clone` requires it to be `Sized`
+    /// fn f<T: Clone + ?Sized>(t: &T) {}
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// The `?Sized` bound is misleading because it cannot be satisfied by an
+    /// unsized type. This lint notifies the user of said redundant bound.
+    pub NEEDLESS_MAYBE_SIZED,
+    Warn,
+    "a `?Sized` bound that is unusable due to a `Sized` requirement"
+}
+declare_lint_pass!(NeedlessMaybeSized => [NEEDLESS_MAYBE_SIZED]);
+
+struct Bound<'tcx> {
+    /// The [`DefId`] of the type parameter the bound refers to
+    param: DefId,
+    ident: Ident,
+
+    trait_bound: &'tcx PolyTraitRef<'tcx>,
+
+    predicate_pos: usize,
+    bound_pos: usize,
+}
+
+/// Finds all of the [`Bound`]s that refer to a type parameter and are not from a macro expansion
+fn type_param_bounds<'tcx>(generics: &'tcx Generics<'tcx>) -> impl Iterator<Item = Bound<'tcx>> {
+    generics
+        .predicates
+        .iter()
+        .enumerate()
+        .filter_map(|(predicate_pos, predicate)| {
+            let WherePredicateKind::BoundPredicate(bound_predicate) = &predicate.kind else {
+                return None;
+            };
+
+            let (param, ident) = bound_predicate.bounded_ty.as_generic_param()?;
+
+            Some(
+                bound_predicate
+                    .bounds
+                    .iter()
+                    .enumerate()
+                    .filter_map(move |(bound_pos, bound)| match bound {
+                        GenericBound::Trait(trait_bound) => {
+                            Some(Bound { param, ident, trait_bound, predicate_pos, bound_pos })
+                        }
+                        GenericBound::Outlives(_) | GenericBound::Use(..) => None,
+                    })
+                    .filter(|bound| !bound.trait_bound.span.from_expansion()),
+            )
+        })
+        .flatten()
+}
+
+/// Searches the supertraits of the trait referred to by `trait_bound` recursively, returning the
+/// path taken to find a `Sized` bound if one is found
+fn path_to_sized_bound(cx: &LateContext<'_>, trait_bound: &PolyTraitRef<'_>) -> Option<Vec<DefId>> {
+    fn search(cx: &LateContext<'_>, path: &mut Vec<DefId>) -> bool {
+        let trait_def_id = *path.last().unwrap();
+
+        if Some(trait_def_id) == cx.tcx.lang_items().sized_trait() {
+            return true;
+        }
+
+        for (predicate, _) in
+            cx.tcx.explicit_super_predicates_of(trait_def_id).iter_identity_copied()
+        {
+            if let ClauseKind::Trait(trait_predicate) = predicate.kind().skip_binder()
+                && trait_predicate.polarity == PredicatePolarity::Positive
+                && !path.contains(&trait_predicate.def_id())
+            {
+                path.push(trait_predicate.def_id());
+                if search(cx, path) {
+                    return true;
+                }
+                path.pop();
+            }
+        }
+
+        false
+    }
+
+    let mut path = vec![trait_bound.trait_ref.trait_def_id()?];
+    search(cx, &mut path).then_some(path)
+}
+
+impl LateLintPass<'_> for NeedlessMaybeSized {
+    fn check_generics(&mut self, cx: &LateContext<'_>, generics: &Generics<'_>) {
+        let Some(sized_trait) = cx.tcx.lang_items().sized_trait() else {
+            return;
+        };
+
+        let maybe_sized_params: DefIdMap<_> = type_param_bounds(generics)
+            .filter(|bound| {
+                bound.trait_bound.trait_ref.trait_def_id() == Some(sized_trait)
+                    && matches!(bound.trait_bound.modifiers.polarity, BoundPolarity::Maybe(_))
+            })
+            .map(|bound| (bound.param, bound))
+            .collect();
+
+        for bound in type_param_bounds(generics) {
+            if bound.trait_bound.modifiers == TraitBoundModifiers::NONE
+                && let Some(sized_bound) = maybe_sized_params.get(&bound.param)
+                && let Some(path) = path_to_sized_bound(cx, bound.trait_bound)
+            {
+                cx.span_lint(NEEDLESS_MAYBE_SIZED, sized_bound.trait_bound.span, |diag| {
+                    diag.primary_message(
+                        "`?Sized` bound is ignored because of a `Sized` requirement",
+                    );
+                    let ty_param = sized_bound.ident;
+                    diag.span_note(
+                        bound.trait_bound.span,
+                        format!("`{ty_param}` cannot be unsized because of the bound"),
+                    );
+
+                    for &[current_id, next_id] in path.array_windows() {
+                        let current = cx.tcx.item_name(current_id);
+                        let next = cx.tcx.item_name(next_id);
+                        diag.note(format!("...because `{current}` has the bound `{next}`"));
+                    }
+
+                    diag.span_suggestion_verbose(
+                        generics.span_for_bound_removal(
+                            sized_bound.predicate_pos,
+                            sized_bound.bound_pos,
+                        ),
+                        "change the bounds that require `Sized`, or remove the `?Sized` bound",
+                        "",
+                        Applicability::MaybeIncorrect,
+                    );
+                });
+
+                return;
+            }
+        }
+    }
+}

library/std/src/sync/nonpoison/mutex.rs

@@ -389,7 +389,7 @@ impl<T> From<T> for Mutex<T> {
 }
 
 #[unstable(feature = "nonpoison_mutex", issue = "134645")]
-impl<T: ?Sized + Default> Default for Mutex<T> {
+impl<T: Default> Default for Mutex<T> {
     /// Creates a `Mutex<T>`, with the `Default` value for T.
     fn default() -> Mutex<T> {
         Mutex::new(Default::default())

library/std/src/sync/poison/mutex.rs

@@ -683,7 +683,7 @@ impl<T> From<T> for Mutex<T> {
 }
 
 #[stable(feature = "mutex_default", since = "1.10.0")]
-impl<T: ?Sized + Default> Default for Mutex<T> {
+impl<T: Default> Default for Mutex<T> {
     /// Creates a `Mutex<T>`, with the `Default` value for T.
     fn default() -> Mutex<T> {
         Mutex::new(Default::default())

tests/ui/issues/issue-48728.rs

@@ -4,8 +4,7 @@
 //@ check-pass
 #[derive(Clone)]
 struct Node<T: ?Sized>(Box<T>);
-
-impl<T: Clone + ?Sized> Clone for Node<[T]> {
+impl<T: Clone> Clone for Node<[T]> {
     fn clone(&self) -> Self {
         Node(Box::clone(&self.0))
     }

tests/ui/lint/lint-needless-maybe-sized.rs

@@ -0,0 +1,133 @@
+#![deny(needless_maybe_sized)]
+
+fn directly<T: Sized + ?Sized>(t: &T) {}
+//~^ ERROR needless_maybe_sized
+
+trait A: Sized {}
+trait B: A {}
+
+fn depth_1<T: A + ?Sized>(t: &T) {}
+//~^ ERROR needless_maybe_sized
+fn depth_2<T: B + ?Sized>(t: &T) {}
+//~^ ERROR needless_maybe_sized
+
+// We only need to show one
+fn multiple_paths<T: A + B + ?Sized>(t: &T) {}
+//~^ ERROR needless_maybe_sized
+
+fn in_where<T>(t: &T)
+where
+    T: Sized + ?Sized,
+    //~^ ERROR needless_maybe_sized
+{
+}
+
+fn mixed_1<T: Sized>(t: &T)
+where
+    T: ?Sized,
+    //~^ ERROR needless_maybe_sized
+{
+}
+
+fn mixed_2<T: ?Sized>(t: &T)
+//~^ ERROR needless_maybe_sized
+where
+    T: Sized,
+{
+}
+
+fn mixed_3<T>(t: &T)
+where
+    T: Sized,
+    T: ?Sized,
+    //~^ ERROR needless_maybe_sized
+{
+}
+
+struct Struct<T: Sized + ?Sized>(T);
+//~^ ERROR needless_maybe_sized
+
+impl<T: Sized + ?Sized> Struct<T> {
+    //~^ ERROR needless_maybe_sized
+    fn method<U: Sized + ?Sized>(&self) {}
+    //~^ ERROR needless_maybe_sized
+}
+
+enum Enum<T: Sized + ?Sized + 'static> {
+    //~^ ERROR needless_maybe_sized
+    Variant(&'static T),
+}
+
+union Union<'a, T: Sized + ?Sized> {
+    //~^ ERROR needless_maybe_sized
+    a: &'a T,
+}
+
+trait Trait<T: Sized + ?Sized> {
+    //~^ ERROR needless_maybe_sized
+    fn trait_method<U: Sized + ?Sized>() {}
+    //~^ ERROR needless_maybe_sized
+
+    type GAT<U: Sized + ?Sized>;
+    //~^ ERROR needless_maybe_sized
+
+    type Assoc: Sized + ?Sized; // False negative
+}
+
+trait SecondInTrait: Send + Sized {}
+fn second_in_trait<T: ?Sized + SecondInTrait>() {}
+//~^ ERROR needless_maybe_sized
+
+fn impl_trait(_: &(impl Sized + ?Sized)) {}
+//~^ ERROR needless_maybe_sized
+
+trait GenericTrait<T>: Sized {}
+fn in_generic_trait<T: GenericTrait<U> + ?Sized, U>() {}
+//~^ ERROR needless_maybe_sized
+
+mod larger_graph {
+    // C1  C2  Sized
+    //  \  /\  /
+    //   B1  B2
+    //    \  /
+    //     A1
+
+    trait C1 {}
+    trait C2 {}
+    trait B1: C1 + C2 {}
+    trait B2: C2 + Sized {}
+    trait A1: B1 + B2 {}
+
+    fn larger_graph<T: A1 + ?Sized>() {}
+    //~^ ERROR needless_maybe_sized
+}
+
+// Should not lint
+
+fn sized<T: Sized>() {}
+fn maybe_sized<T: ?Sized>() {}
+
+struct SeparateBounds<T: ?Sized>(T);
+impl<T: Sized> SeparateBounds<T> {}
+
+trait P {}
+trait Q: P {}
+
+fn ok_depth_1<T: P + ?Sized>() {}
+fn ok_depth_2<T: Q + ?Sized>() {}
+
+//external! {
+//    fn in_macro<T: Clone + ?Sized>(t: &T) {}
+
+//    fn with_local_clone<T: $Clone + ?Sized>(t: &T) {}
+//}
+
+#[derive(Clone)]
+struct InDerive<T: ?Sized> {
+    t: T,
+}
+
+struct Refined<T: ?Sized>(T);
+impl<T: Sized> Refined<T> {}
+
+fn main() {}