Extends lint

- Extends lint to check for redundant sizedness bounds.
- Applies the extended lint's suggestions to `clone.rs` as flagged by the lint.

Author: CrooseGit

compiler/rustc_lint/src/redundant_sizedness_bound.rs

@@ -10,35 +10,43 @@ use rustc_span::symbol::Ident;
 use crate::{LateContext, LateLintPass, LintContext};
 
 declare_lint! {
-    /// The `redundant_sizedness_bound` lint detects `?Sized` bounds applied to type parameters that cannot be unsized.
+    /// The `redundant_sizedness_bound` lint detects redundant sizedness bounds applied to type parameters that are already
+    /// otherwise implied.
     ///
     /// ### Example
     ///
     /// ```rust
+    /// #![feature(sized_hierarchy)]
+    /// use std::marker::MetaSized;
     /// // `T` cannot be unsized because `Clone` requires it to be `Sized`
     /// fn f<T: Clone + ?Sized>(t: &T) {}
+    /// // `T` is `Sized` due to `Clone` bound, thereby implying `MetaSized` and making the explicit `MetaSized` bound redundant.
+    /// fn g<T: MetaSized + Clone>(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.
+    /// unsized type, similarly sizedness bounds that are already implied by other bounds.
+    /// This lint notifies the user of said redundant bound.
     pub REDUNDANT_SIZEDNESS_BOUND,
     Warn,
-    "a `?Sized` bound that is unusable due to a `Sized` requirement"
+    "a sizedness bound that is redundant due to another bound"
 }
 declare_lint_pass!(RedundantSizednessBound => [REDUNDANT_SIZEDNESS_BOUND]);
 
 struct Bound<'tcx> {
     /// The [`DefId`] of the type parameter the bound refers to
     param: DefId,
+    /// Identifier of type parameter
     ident: Ident,
-
+    /// A reference to the trait bound applied to the parameter
     trait_bound: &'tcx PolyTraitRef<'tcx>,
-
+    /// The index of the predicate within the generics predicate list
     predicate_pos: usize,
+    /// Position of the bound in the bounds list of a predicate
     bound_pos: usize,
 }
 
@@ -73,12 +81,16 @@ fn type_param_bounds<'tcx>(generics: &'tcx Generics<'tcx>) -> impl Iterator<Item
 }
 
 /// 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 {
+/// path taken to find the `target` bound if one is found
+fn path_to_bound(
+    cx: &LateContext<'_>,
+    trait_bound: &PolyTraitRef<'_>,
+    target: DefId,
+) -> Option<Vec<DefId>> {
+    fn search(cx: &LateContext<'_>, path: &mut Vec<DefId>, target: DefId) -> bool {
         let trait_def_id = *path.last().unwrap();
 
-        if Some(trait_def_id) == cx.tcx.lang_items().sized_trait() {
+        if trait_def_id == target {
             return true;
         }
 
@@ -90,7 +102,7 @@ fn path_to_sized_bound(cx: &LateContext<'_>, trait_bound: &PolyTraitRef<'_>) ->
                 && !path.contains(&trait_predicate.def_id())
             {
                 path.push(trait_predicate.def_id());
-                if search(cx, path) {
+                if search(cx, path, target) {
                     return true;
                 }
                 path.pop();
@@ -101,36 +113,53 @@ fn path_to_sized_bound(cx: &LateContext<'_>, trait_bound: &PolyTraitRef<'_>) ->
     }
 
     let mut path = vec![trait_bound.trait_ref.trait_def_id()?];
-    search(cx, &mut path).then_some(path)
+    search(cx, &mut path, target).then_some(path)
 }
 
-impl LateLintPass<'_> for RedundantSizednessBound {
-    fn check_generics(&mut self, cx: &LateContext<'_>, generics: &Generics<'_>) {
-        let Some(sized_trait) = cx.tcx.lang_items().sized_trait() else {
-            return;
-        };
+// Checks if there exists a bound `redundant_bound` that is already implied by `implicit_bound`
+fn check_redundant_sizedness_bound(
+    redundant_bound: DefId,
+    redundant_bound_polarity: BoundPolarity,
+    implicit_bound: DefId,
+    cx: &LateContext<'_>,
+    generics: &Generics<'_>,
+) -> bool {
+    let redundant_sized_params: DefIdMap<_> = type_param_bounds(generics)
+        .filter(|bound| {
+            bound.trait_bound.trait_ref.trait_def_id() == Some(redundant_bound)
+                && std::mem::discriminant(&bound.trait_bound.modifiers.polarity)
+                    == std::mem::discriminant(&redundant_bound_polarity)
+        })
+        .map(|bound| (bound.param, bound))
+        .collect();
 
-        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(REDUNDANT_SIZEDNESS_BOUND, sized_bound.trait_bound.span, |diag| {
-                    diag.primary_message(
-                        "`?Sized` bound is ignored because of a `Sized` requirement",
-                    );
-                    let ty_param = sized_bound.ident;
+    for bound in type_param_bounds(generics) {
+        if bound.trait_bound.modifiers == TraitBoundModifiers::NONE
+            && let Some(redundant_sized_bound) = redundant_sized_params.get(&bound.param)
+            && let Some(path) = path_to_bound(cx, bound.trait_bound, implicit_bound)
+        {
+            let redundant_bound_polarity_str = match redundant_bound_polarity {
+                BoundPolarity::Maybe(_) => "?",
+                _ => "",
+            };
+            cx.span_lint(
+                REDUNDANT_SIZEDNESS_BOUND,
+                redundant_sized_bound.trait_bound.span,
+                |diag| {
+                    let redundant_bound_str = cx.tcx.def_path_str(redundant_bound);
+                    let implicit_bound_str = cx.tcx.def_path_str(implicit_bound);
+
+                    diag.primary_message(format!(
+                        "`{}{}` bound is redundant because of a `{}` requirement",
+                        redundant_bound_polarity_str, redundant_bound_str, implicit_bound_str,
+                    ));
+                    let ty_param = redundant_sized_bound.ident;
                     diag.span_note(
                         bound.trait_bound.span,
-                        format!("`{ty_param}` cannot be unsized because of the bound"),
+                        format!(
+                            "`{ty_param}` is implied to be `{}` because of the bound",
+                            implicit_bound_str,
+                        ),
                     );
 
                     for &[current_id, next_id] in path.array_windows() {
@@ -141,17 +170,72 @@ impl LateLintPass<'_> for RedundantSizednessBound {
 
                     diag.span_suggestion_verbose(
                         generics.span_for_bound_removal(
-                            sized_bound.predicate_pos,
-                            sized_bound.bound_pos,
+                            redundant_sized_bound.predicate_pos,
+                            redundant_sized_bound.bound_pos,
+                        ),
+                        format!(
+                            "change the bounds that require `{}`, or remove the `{}{}` bound",
+                            implicit_bound_str, redundant_bound_polarity_str, redundant_bound_str,
                         ),
-                        "change the bounds that require `Sized`, or remove the `?Sized` bound",
                         "",
                         Applicability::MaybeIncorrect,
                     );
-                });
+                },
+            );
 
-                return;
-            }
+            return true;
+        }
+    }
+    false
+}
+
+impl LateLintPass<'_> for RedundantSizednessBound {
+    fn check_generics(&mut self, cx: &LateContext<'_>, generics: &Generics<'_>) {
+        let Some(sized_trait) = cx.tcx.lang_items().sized_trait() else {
+            return;
+        };
+        let Some(meta_sized_trait) = cx.tcx.lang_items().meta_sized_trait() else {
+            return;
+        };
+        let Some(pointee_sized_trait) = cx.tcx.lang_items().pointee_sized_trait() else {
+            return;
+        };
+
+        if check_redundant_sizedness_bound(
+            sized_trait,
+            BoundPolarity::Maybe(Default::default()),
+            sized_trait,
+            cx,
+            generics,
+        ) {
+            return;
+        }
+        if check_redundant_sizedness_bound(
+            meta_sized_trait,
+            BoundPolarity::Positive,
+            sized_trait,
+            cx,
+            generics,
+        ) {
+            return;
+        }
+        if check_redundant_sizedness_bound(
+            pointee_sized_trait,
+            BoundPolarity::Positive,
+            sized_trait,
+            cx,
+            generics,
+        ) {
+            return;
+        }
+        if check_redundant_sizedness_bound(
+            pointee_sized_trait,
+            BoundPolarity::Positive,
+            meta_sized_trait,
+            cx,
+            generics,
+        ) {
+            return;
         }
     }
 }

library/core/src/clone.rs

@@ -36,7 +36,7 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-use crate::marker::{Destruct, PointeeSized};
+use crate::marker::Destruct;
 
 mod uninit;
 
@@ -323,7 +323,7 @@ impl_use_cloned! {
     reason = "deriving hack, should not be public",
     issue = "none"
 )]
-pub struct AssertParamIsClone<T: Clone + PointeeSized> {
+pub struct AssertParamIsClone<T: Clone> {
     _field: crate::marker::PhantomData<T>,
 }
 #[doc(hidden)]
@@ -333,7 +333,7 @@ pub struct AssertParamIsClone<T: Clone + PointeeSized> {
     reason = "deriving hack, should not be public",
     issue = "none"
 )]
-pub struct AssertParamIsCopy<T: Copy + PointeeSized> {
+pub struct AssertParamIsCopy<T: Copy> {
     _field: crate::marker::PhantomData<T>,
 }