generalize re-export stability checks

Signed-off-by: Amirhossein Akhlaghpour <m9.akhlaghpoor@gmail.com>

Author: amirHdev

compiler/rustc_lint_defs/src/builtin.rs

@@ -54,6 +54,7 @@ pub mod hardwired {
             FUNCTION_ITEM_REFERENCES,
             HIDDEN_GLOB_REEXPORTS,
             ILL_FORMED_ATTRIBUTE_INPUT,
+            INCOMPATIBLE_REEXPORT_STABILITY,
             INCOMPLETE_INCLUDE,
             INEFFECTIVE_UNSTABLE_TRAIT_IMPL,
             INLINE_NO_SANITIZE,
@@ -152,7 +153,6 @@ pub mod hardwired {
             UNUSED_MUT,
             UNUSED_QUALIFICATIONS,
             UNUSED_UNSAFE,
-            UNUSED_UNSTABLE_REEXPORT_ATTRIBUTES,
             UNUSED_VARIABLES,
             UNUSED_VISIBILITIES,
             USELESS_DEPRECATED,
@@ -2793,20 +2793,21 @@ declare_lint! {
 }
 
 declare_lint! {
-    /// The `unused_unstable_reexport_attributes` lint detects `#[unstable]` attributes
-    /// on re-exports where the attribute does not make the re-exported path unstable.
+    /// The `incompatible_reexport_stability` lint detects stability
+    /// annotations on re-exports that are incompatible with the stability
+    /// metadata of the re-exported item.
     ///
     /// ### Example
     ///
     /// ```rust,compile_fail
     /// #![feature(staged_api)]
     /// #![stable(feature = "test", since = "1.0.0")]
     ///
-    /// #[stable(feature = "test", since = "1.0.0")]
+    /// #[stable(feature = "original", since = "1.0.0")]
     /// pub struct S;
     ///
-    /// #[unstable(feature = "reexport", issue = "none")]
-    /// pub use crate::S as T;
+    /// #[stable(feature = "different", since = "1.0.0")]
+    /// pub use self::S as T;
     ///
     /// fn main() {}
     /// ```
@@ -2815,11 +2816,14 @@ declare_lint! {
     ///
     /// ### Explanation
     ///
-    /// Stability attributes on re-exports do not currently change the
-    /// stability of an otherwise stable re-exported item.
-    pub UNUSED_UNSTABLE_REEXPORT_ATTRIBUTES,
+    /// Stability annotations on re-exports should be compatible with the
+    /// stability metadata of the item being re-exported. Stable metadata is
+    /// compared by feature and `since`, while unstable metadata is compared by
+    /// feature and issue. Stable re-exports of unstable definitions remain
+    /// handled by the existing stability machinery.
+    pub INCOMPATIBLE_REEXPORT_STABILITY,
     Deny,
-    "detects ineffective `#[unstable]` attributes on re-exports",
+    "detects incompatible stability annotations on re-exports",
     @feature_gate = staged_api;
 }
 

compiler/rustc_passes/src/diagnostics.rs

@@ -965,8 +965,8 @@ pub(crate) struct UnnecessaryPartialStableFeature {
 pub(crate) struct IneffectiveUnstableImpl;
 
 #[derive(Diagnostic)]
-#[diag("`#[unstable]` does not make this re-exported path unstable")]
-pub(crate) struct UnusedUnstableReexportAttributes;
+#[diag("stability annotation on this re-export does not match the re-exported item")]
+pub(crate) struct IncompatibleReexportStability;
 
 // FIXME(jdonszelmann): move back to rustc_attr
 #[derive(Diagnostic)]

compiler/rustc_passes/src/stability.rs

@@ -18,8 +18,8 @@ use rustc_hir::{
 };
 use rustc_lint_defs as lint;
 use rustc_lint_defs::builtin::{
-    DEPRECATED, DUPLICATE_FEATURES, INEFFECTIVE_UNSTABLE_TRAIT_IMPL, STABLE_FEATURES,
-    UNUSED_UNSTABLE_REEXPORT_ATTRIBUTES,
+    DEPRECATED, DUPLICATE_FEATURES, INCOMPATIBLE_REEXPORT_STABILITY,
+    INEFFECTIVE_UNSTABLE_TRAIT_IMPL, STABLE_FEATURES,
 };
 use rustc_middle::hir::nested_filter;
 use rustc_middle::metadata::Reexport;
@@ -525,9 +525,9 @@ impl<'tcx> Visitor<'tcx> for MissingStabilityAnnotations<'tcx> {
 /// Cross-references the feature names of unstable APIs with enabled
 /// features and possibly prints errors.
 fn check_mod_unstable_api_usage(tcx: TyCtxt<'_>, mod_id: LocalModId) {
-    let mut checker = Checker { tcx, mod_id, unstable_reexports: FxIndexMap::default() };
+    let mut checker = Checker { tcx, mod_id, reexport_stability: FxIndexMap::default() };
     tcx.hir_visit_item_likes_in_module(mod_id, &mut checker);
-    checker.emit_unused_unstable_reexport_attributes();
+    checker.emit_incompatible_reexport_stability();
 
     let is_staged_api =
         tcx.sess.opts.unstable_opts.force_unstable_if_unmarked || tcx.features().staged_api();
@@ -557,99 +557,140 @@ pub(crate) fn provide(providers: &mut Providers) {
     };
 }
 
-struct UnstableReexport {
+struct ReexportStability {
     hir_id: HirId,
     span: Span,
     has_target: bool,
-    all_targets_stable: bool,
+    all_targets_compatible: bool,
 }
 
 struct Checker<'tcx> {
     tcx: TyCtxt<'tcx>,
     mod_id: LocalModId,
-    unstable_reexports: FxIndexMap<Span, UnstableReexport>,
+    reexport_stability: FxIndexMap<Span, ReexportStability>,
 }
 
 impl<'tcx> Checker<'tcx> {
-    fn unstable_reexport_span(&self, item: &'tcx hir::Item<'tcx>) -> Option<Span> {
+    fn reexport_stability_attr(&self, item: &'tcx hir::Item<'tcx>) -> Option<(Stability, Span)> {
         let attrs = self.tcx.hir_attrs(item.hir_id());
-        let (stability, span) =
-            find_attr!(attrs, Stability { stability, span } => (*stability, *span))?;
+        find_attr!(attrs, Stability { stability, span } => (*stability, *span))
+    }
+
+    fn stability_is_compatible(reexport: &Stability, target: &Stability) -> bool {
+        match (&reexport.level, &target.level) {
+            (
+                StabilityLevel::Stable { since: reexport_since, .. },
+                StabilityLevel::Stable { since: target_since, .. },
+            ) => {
+                // Avoid another error for an invalid `since`.
+                matches!(
+                    (*reexport_since, *target_since),
+                    (StableSince::Err(_), _) | (_, StableSince::Err(_))
+                ) || (reexport.feature == target.feature && reexport_since == target_since)
+            }
+
+            (
+                StabilityLevel::Unstable { issue: reexport_issue, .. },
+                StabilityLevel::Unstable { issue: target_issue, .. },
+            ) => reexport.feature == target.feature && reexport_issue == target_issue,
 
-        matches!(stability.level, StabilityLevel::Unstable { .. }).then_some(span)
+            // An unstable re-export cannot make a stable item unstable.
+            (StabilityLevel::Unstable { .. }, StabilityLevel::Stable { .. }) => false,
+
+            // Stable re-exports of unstable items are handled elsewhere.
+            (StabilityLevel::Stable { .. }, StabilityLevel::Unstable { .. }) => true,
+        }
     }
 
     fn classify_reexport_targets<Id>(
         &self,
+        own_stability: &Stability,
         targets: impl IntoIterator<Item = Res<Id>>,
     ) -> (bool, bool) {
         let mut has_target = false;
-        let mut all_targets_stable = true;
+        let mut all_targets_compatible = true;
 
         for res in targets {
             match res {
                 Res::Def(_, def_id) => {
                     has_target = true;
 
-                    if self.tcx.lookup_stability(def_id).is_some_and(|stab| !stab.level.is_stable())
+                    if let Some(target_stability) = self.tcx.lookup_stability(def_id)
+                        && !Self::stability_is_compatible(own_stability, &target_stability)
                     {
-                        all_targets_stable = false;
+                        all_targets_compatible = false;
                     }
                 }
 
                 Res::PrimTy(_) => {
                     has_target = true;
-                }
 
-                _ => {
-                    all_targets_stable = false;
+                    // Primitives are stable and have no DefId.
+                    if own_stability.level.is_unstable() {
+                        all_targets_compatible = false;
+                    }
                 }
+
+                // No stability metadata to compare.
+                _ => {}
             }
         }
 
-        (has_target, all_targets_stable)
+        (has_target, all_targets_compatible)
     }
 
-    fn record_unstable_reexport(
+    fn record_reexport_stability(
         &mut self,
         item: &'tcx hir::Item<'tcx>,
         attr_span: Span,
         span: Span,
         has_target: bool,
-        all_targets_stable: bool,
+        all_targets_compatible: bool,
     ) {
-        let entry = self.unstable_reexports.entry(attr_span).or_insert(UnstableReexport {
+        let entry = self.reexport_stability.entry(attr_span).or_insert(ReexportStability {
             hir_id: item.hir_id(),
             span,
             has_target: false,
-            all_targets_stable: true,
+            all_targets_compatible: true,
         });
 
         entry.has_target |= has_target;
-        entry.all_targets_stable &= all_targets_stable;
+
+        // Keep the first bad path for the diagnostic.
+        if entry.all_targets_compatible && !all_targets_compatible {
+            entry.span = span;
+        }
+
+        entry.all_targets_compatible &= all_targets_compatible;
     }
 
-    fn check_single_unstable_reexport(
+    fn check_single_reexport_stability(
         &mut self,
         item: &'tcx hir::Item<'tcx>,
         path: &'tcx UsePath<'tcx>,
     ) {
-        let Some(attr_span) = self.unstable_reexport_span(item) else {
+        let Some((own_stability, attr_span)) = self.reexport_stability_attr(item) else {
             return;
         };
 
-        let (has_target, all_targets_stable) =
-            self.classify_reexport_targets(path.res.present_items());
+        let (has_target, all_targets_compatible) =
+            self.classify_reexport_targets(&own_stability, path.res.present_items());
 
-        self.record_unstable_reexport(item, attr_span, path.span, has_target, all_targets_stable);
+        self.record_reexport_stability(
+            item,
+            attr_span,
+            path.span,
+            has_target,
+            all_targets_compatible,
+        );
     }
 
-    fn check_glob_unstable_reexport(
+    fn check_glob_reexport_stability(
         &mut self,
         item: &'tcx hir::Item<'tcx>,
         path: &'tcx UsePath<'tcx>,
     ) {
-        let Some(attr_span) = self.unstable_reexport_span(item) else {
+        let Some((own_stability, attr_span)) = self.reexport_stability_attr(item) else {
             return;
         };
 
@@ -669,19 +710,26 @@ impl<'tcx> Checker<'tcx> {
             })
             .map(|child| child.res);
 
-        let (has_target, all_targets_stable) = self.classify_reexport_targets(targets);
+        let (has_target, all_targets_compatible) =
+            self.classify_reexport_targets(&own_stability, targets);
 
-        self.record_unstable_reexport(item, attr_span, path.span, has_target, all_targets_stable);
+        self.record_reexport_stability(
+            item,
+            attr_span,
+            path.span,
+            has_target,
+            all_targets_compatible,
+        );
     }
 
-    fn emit_unused_unstable_reexport_attributes(&self) {
-        for reexport in self.unstable_reexports.values() {
-            if reexport.has_target && reexport.all_targets_stable {
+    fn emit_incompatible_reexport_stability(&self) {
+        for reexport in self.reexport_stability.values() {
+            if reexport.has_target && !reexport.all_targets_compatible {
                 self.tcx.emit_node_span_lint(
-                    UNUSED_UNSTABLE_REEXPORT_ATTRIBUTES,
+                    INCOMPATIBLE_REEXPORT_STABILITY,
                     reexport.hir_id,
                     reexport.span,
-                    diagnostics::UnusedUnstableReexportAttributes,
+                    diagnostics::IncompatibleReexportStability,
                 );
             }
         }
@@ -718,14 +766,14 @@ impl<'tcx> Visitor<'tcx> for Checker<'tcx> {
                 if self.tcx.features().staged_api()
                     && self.tcx.local_visibility(item.owner_id.def_id).is_public() =>
             {
-                self.check_single_unstable_reexport(item, path);
+                self.check_single_reexport_stability(item, path);
             }
 
             hir::ItemKind::Use(path, hir::UseKind::Glob)
                 if self.tcx.features().staged_api()
                     && self.tcx.local_visibility(item.owner_id.def_id).is_public() =>
             {
-                self.check_glob_unstable_reexport(item, path);
+                self.check_glob_reexport_stability(item, path);
             }
 
             // For implementations of traits, check the stability of each item

library/alloc/src/alloc.rs

@@ -4,6 +4,8 @@
 
 #[stable(feature = "alloc_module", since = "1.28.0")]
 #[doc(inline)]
+#[allow(clippy::useless_attribute)]
+#[allow(incompatible_reexport_stability)] // This facade has its own path stability.
 pub use core::alloc::*;
 use core::mem::Alignment;
 use core::ptr::{self, NonNull};

library/alloc/src/collections/mod.rs

@@ -20,6 +20,8 @@ pub mod btree_map {
     //! An ordered map based on a B-Tree.
     #[stable(feature = "rust1", since = "1.0.0")]
     #[cfg(not(test))]
+    #[allow(clippy::useless_attribute)]
+    #[allow(incompatible_reexport_stability)] // Public facade over internal B-tree items.
     pub use super::btree::map::*;
 }
 
@@ -29,6 +31,8 @@ pub mod btree_set {
     //! An ordered set based on a B-Tree.
     #[stable(feature = "rust1", since = "1.0.0")]
     #[cfg(not(test))]
+    #[allow(clippy::useless_attribute)]
+    #[allow(incompatible_reexport_stability)] // Public facade over internal B-tree items.
     pub use super::btree::set::*;
 }
 

library/alloc/src/fmt.rs

@@ -600,10 +600,14 @@ pub use core::fmt::{Arguments, write};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use core::fmt::{Binary, Octal};
 #[stable(feature = "rust1", since = "1.0.0")]
+#[allow(clippy::useless_attribute)]
+#[allow(incompatible_reexport_stability)] // This re-export has its own stability.
 pub use core::fmt::{Debug, Display};
 #[unstable(feature = "formatting_options", issue = "118117")]
 pub use core::fmt::{DebugAsHex, FormattingOptions, Sign};
 #[stable(feature = "rust1", since = "1.0.0")]
+#[allow(clippy::useless_attribute)]
+#[allow(incompatible_reexport_stability)] // This re-export has its own stability.
 pub use core::fmt::{DebugList, DebugMap, DebugSet, DebugStruct, DebugTuple};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use core::fmt::{Formatter, Result, Write};

library/alloc/src/io/mod.rs

@@ -195,7 +195,7 @@ pub use core::io::const_error;
 #[unstable(feature = "core_io_borrowed_buf", issue = "117693")]
 pub use core::io::{BorrowedBuf, BorrowedCursor};
 #[allow(clippy::useless_attribute)]
-#[allow(unused_unstable_reexport_attributes)] // FIXME(#161153)
+#[allow(incompatible_reexport_stability)] // FIXME(#161153)
 #[unstable(feature = "alloc_io", issue = "154046")]
 pub use core::io::{
     Chain, Cursor, Empty, Error, ErrorKind, IoSlice, IoSliceMut, Repeat, Result, Seek, SeekFrom,
@@ -212,7 +212,7 @@ use core::io::{
 use self::read::{append_to_string, default_read_buf_exact, default_read_exact};
 use self::util::{bytes, lines, split, uninlined_slow_read_byte};
 #[allow(clippy::useless_attribute)]
-#[allow(unused_unstable_reexport_attributes)] // FIXME(#161153)
+#[allow(incompatible_reexport_stability)] // FIXME(#161153)
 #[unstable(feature = "alloc_io", issue = "154046")]
 pub use self::{
     buf_read::BufRead,