Stabilize the supertrait_item_shadowing feature

Tracking issue: #89151

Author: Amanieu

compiler/rustc_feature/src/accepted.rs

@@ -409,6 +409,8 @@ declare_features! (
     (accepted, struct_field_attributes, "1.20.0", Some(38814)),
     /// Allows struct variants `Foo { baz: u8, .. }` in enums (RFC 418).
     (accepted, struct_variant, "1.0.0", None),
+    /// Allows subtrait items to shadow supertrait items.
+    (accepted, supertrait_item_shadowing, "CURRENT_RUSTC_VERSION", Some(89151)),
     /// Allows `#[target_feature(...)]`.
     (accepted, target_feature, "1.27.0", None),
     /// Allows the use of `#[target_feature]` on safe functions.

compiler/rustc_feature/src/unstable.rs

@@ -648,8 +648,6 @@ declare_features! (
     (unstable, string_deref_patterns, "1.67.0", Some(87121)),
     /// Allows `super let` statements.
     (unstable, super_let, "1.88.0", Some(139076)),
-    /// Allows subtrait items to shadow supertrait items.
-    (unstable, supertrait_item_shadowing, "1.86.0", Some(89151)),
     /// Allows the use of target_feature when a function is marked inline(always).
     (unstable, target_feature_inline_always, "1.91.0", Some(145574)),
     /// Allows using `#[thread_local]` on `static` items.

compiler/rustc_hir_typeck/src/method/probe.rs

@@ -1728,12 +1728,10 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
             // We collapse to a subtrait pick *after* filtering unstable candidates
             // to make sure we don't prefer a unstable subtrait method over a stable
             // supertrait method.
-            if self.tcx.features().supertrait_item_shadowing() {
-                if let Some(pick) =
-                    self.collapse_candidates_to_subtrait_pick(self_ty, &applicable_candidates)
-                {
-                    return Some(Ok(pick));
-                }
+            if let Some(pick) =
+                self.collapse_candidates_to_subtrait_pick(self_ty, &applicable_candidates)
+            {
+                return Some(Ok(pick));
             }
 
             let sources =

compiler/rustc_lint_defs/src/builtin.rs

@@ -4923,11 +4923,8 @@ declare_lint! {
     /// silently, this lint detects these cases when users want to deny them
     /// or fix the call sites.
     pub SUPERTRAIT_ITEM_SHADOWING_USAGE,
-    // FIXME(supertrait_item_shadowing): It is not decided if this should
-    // warn by default at the call site.
     Allow,
     "detects when a supertrait item is shadowed by a subtrait item",
-    @feature_gate = supertrait_item_shadowing;
 }
 
 declare_lint! {
@@ -4962,11 +4959,8 @@ declare_lint! {
     /// silently, this lint detects these cases when users want to deny them
     /// or fix their trait definitions.
     pub SUPERTRAIT_ITEM_SHADOWING_DEFINITION,
-    // FIXME(supertrait_item_shadowing): It is not decided if this should
-    // warn by default at the usage site.
-    Allow,
+    Warn,
     "detects when a supertrait item is shadowed by a subtrait item",
-    @feature_gate = supertrait_item_shadowing;
 }
 
 declare_lint! {

compiler/rustc_middle/src/mir/interpret/pointer.rs

@@ -70,7 +70,7 @@ pub trait Provenance: Copy + PartialEq + fmt::Debug + 'static {
     const WILDCARD: Option<Self>;
 
     /// Determines how a pointer should be printed.
-    fn fmt(ptr: &Pointer<Self>, f: &mut fmt::Formatter<'_>) -> fmt::Result;
+    fn fmt_ptr(ptr: &Pointer<Self>, f: &mut fmt::Formatter<'_>) -> fmt::Result;
 
     /// If `OFFSET_IS_ADDR == false`, provenance must always be able to
     /// identify the allocation this ptr points to (i.e., this must return `Some`).
@@ -174,7 +174,7 @@ impl Provenance for CtfeProvenance {
     // `CtfeProvenance` does not implement wildcard provenance.
     const WILDCARD: Option<Self> = None;
 
-    fn fmt(ptr: &Pointer<Self>, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt_ptr(ptr: &Pointer<Self>, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         // Print AllocId.
         fmt::Debug::fmt(&ptr.provenance.alloc_id(), f)?; // propagates `alternate` flag
         // Print offset only if it is non-zero.
@@ -206,7 +206,7 @@ impl Provenance for AllocId {
     // `AllocId` does not implement wildcard provenance.
     const WILDCARD: Option<Self> = None;
 
-    fn fmt(ptr: &Pointer<Self>, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn fmt_ptr(ptr: &Pointer<Self>, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         // Forward `alternate` flag to `alloc_id` printing.
         if f.alternate() {
             write!(f, "{:#?}", ptr.provenance)?;
@@ -248,14 +248,14 @@ static_assert_size!(Pointer<Option<CtfeProvenance>>, 16);
 // all the Miri types.
 impl<Prov: Provenance> fmt::Debug for Pointer<Prov> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        Provenance::fmt(self, f)
+        Provenance::fmt_ptr(self, f)
     }
 }
 
 impl<Prov: Provenance> fmt::Debug for Pointer<Option<Prov>> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.provenance {
-            Some(prov) => Provenance::fmt(&Pointer::new(prov, self.offset), f),
+            Some(prov) => Provenance::fmt_ptr(&Pointer::new(prov, self.offset), f),
             None => write!(f, "{:#x}[noalloc]", self.offset.bytes()),
         }
     }

library/compiler-builtins/compiler-builtins/src/int/addsub.rs

@@ -20,6 +20,7 @@ trait UAddSub: DInt + Int {
 
 impl UAddSub for u128 {}
 
+#[allow(supertrait_item_shadowing_definition)]
 trait AddSub: Int
 where
     <Self as MinInt>::Unsigned: UAddSub,

library/compiler-builtins/compiler-builtins/src/int/mul.rs

@@ -1,5 +1,6 @@
 use crate::int::{DInt, HInt, Int};
 
+#[allow(supertrait_item_shadowing_definition)]
 trait Mul: DInt + Int
 where
     Self::H: DInt,

library/core/src/array/mod.rs

@@ -442,7 +442,7 @@ impl<T: Copy, const N: usize> Copy for [T; N] {}
 impl<T: Clone, const N: usize> Clone for [T; N] {
     #[inline]
     fn clone(&self) -> Self {
-        SpecArrayClone::clone(self)
+        SpecArrayClone::spec_clone(self)
     }
 
     #[inline]
@@ -452,19 +452,19 @@ impl<T: Clone, const N: usize> Clone for [T; N] {
 }
 
 trait SpecArrayClone: Clone {
-    fn clone<const N: usize>(array: &[Self; N]) -> [Self; N];
+    fn spec_clone<const N: usize>(array: &[Self; N]) -> [Self; N];
 }
 
 impl<T: Clone> SpecArrayClone for T {
     #[inline]
-    default fn clone<const N: usize>(array: &[T; N]) -> [T; N] {
+    default fn spec_clone<const N: usize>(array: &[T; N]) -> [T; N] {
         from_trusted_iterator(array.iter().cloned())
     }
 }
 
 impl<T: Copy> SpecArrayClone for T {
     #[inline]
-    fn clone<const N: usize>(array: &[T; N]) -> [T; N] {
+    fn spec_clone<const N: usize>(array: &[T; N]) -> [T; N] {
         *array
     }
 }

library/core/src/iter/adapters/array_chunks.rs

@@ -104,7 +104,7 @@ where
         Self: Sized,
         F: FnMut(B, Self::Item) -> B,
     {
-        <Self as SpecFold>::fold(self, init, f)
+        <Self as SpecFold>::spec_fold(self, init, f)
     }
 }
 
@@ -196,7 +196,7 @@ where
 }
 
 trait SpecFold: Iterator {
-    fn fold<B, F>(self, init: B, f: F) -> B
+    fn spec_fold<B, F>(self, init: B, f: F) -> B
     where
         Self: Sized,
         F: FnMut(B, Self::Item) -> B;
@@ -207,7 +207,7 @@ where
     I: Iterator,
 {
     #[inline]
-    default fn fold<B, F>(mut self, init: B, f: F) -> B
+    default fn spec_fold<B, F>(mut self, init: B, f: F) -> B
     where
         Self: Sized,
         F: FnMut(B, Self::Item) -> B,
@@ -221,7 +221,7 @@ where
     I: Iterator + TrustedRandomAccessNoCoerce,
 {
     #[inline]
-    fn fold<B, F>(mut self, init: B, mut f: F) -> B
+    fn spec_fold<B, F>(mut self, init: B, mut f: F) -> B
     where
         Self: Sized,
         F: FnMut(B, Self::Item) -> B,

src/tools/clippy/tests/ui/implied_bounds_in_impls.fixed

@@ -144,6 +144,7 @@ fn issue11880() {
         type U;
     }
     trait Y: X {
+        #[allow(supertrait_item_shadowing_definition)]
         type T;
         type V;
     }