Fix test failures by requiring a use also be public

Deprecation warnings that were handled via eval_stability should now be emitted even for items which are skipping the unstable message

Author: semicoleon

compiler/rustc_middle/src/middle/stability.rs

@@ -9,9 +9,9 @@ use rustc_attr::{self as attr, ConstStability, Deprecation, Stability};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::{Applicability, Diagnostic};
 use rustc_feature::GateIssue;
-use rustc_hir as hir;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, LocalDefId};
+use rustc_hir::{self as hir};
 use rustc_hir::{self, HirId};
 use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_session::lint::builtin::{DEPRECATED, DEPRECATED_IN_FUTURE, SOFT_UNSTABLE};
@@ -306,6 +306,20 @@ fn suggestion_for_allocator_api(
     None
 }
 
+/// An override option for eval_stability.
+pub enum EvalOverride {
+    /// Don't emit an unstable error for the item
+    AllowUnstable,
+    /// Handle the item normally
+    None,
+}
+
+impl Default for EvalOverride {
+    fn default() -> Self {
+        Self::None
+    }
+}
+
 impl<'tcx> TyCtxt<'tcx> {
     /// Evaluates the stability of an item.
     ///
@@ -322,6 +336,28 @@ impl<'tcx> TyCtxt<'tcx> {
         id: Option<HirId>,
         span: Span,
         method_span: Option<Span>,
+    ) -> EvalResult {
+        self.eval_stability_override(def_id, id, span, method_span, Default::default())
+    }
+
+    /// Evaluates the stability of an item.
+    ///
+    /// Returns `EvalResult::Allow` if the item is stable, or unstable but the corresponding
+    /// `#![feature]` has been provided. Returns `EvalResult::Deny` which describes the offending
+    /// unstable feature otherwise.
+    ///
+    /// If `id` is `Some(_)`, this function will also check if the item at `def_id` has been
+    /// deprecated. If the item is indeed deprecated, we will emit a deprecation lint attached to
+    /// `id`.
+    ///
+    /// Pass `EvalOverride::AllowUnstable` to `eval_override` to force an unstable item to be allowed. Deprecation warnings will be emitted normally.
+    pub fn eval_stability_override(
+        self,
+        def_id: DefId,
+        id: Option<HirId>,
+        span: Span,
+        method_span: Option<Span>,
+        eval_override: EvalOverride,
     ) -> EvalResult {
         // Deprecated attributes apply in-crate and cross-crate.
         if let Some(id) = id {
@@ -419,6 +455,10 @@ impl<'tcx> TyCtxt<'tcx> {
                     }
                 }
 
+                if matches!(eval_override, EvalOverride::AllowUnstable) {
+                    return EvalResult::Allow;
+                }
+
                 let suggestion = suggestion_for_allocator_api(self, def_id, span, feature);
                 EvalResult::Deny { feature, reason, issue, suggestion, is_soft }
             }
@@ -445,11 +485,38 @@ impl<'tcx> TyCtxt<'tcx> {
         span: Span,
         method_span: Option<Span>,
     ) {
-        self.check_optional_stability(def_id, id, span, method_span, |span, def_id| {
-            // The API could be uncallable for other reasons, for example when a private module
-            // was referenced.
-            self.sess.delay_span_bug(span, &format!("encountered unmarked API: {:?}", def_id));
-        })
+        self.check_stability_override(def_id, id, span, method_span, Default::default())
+    }
+
+    /// Checks if an item is stable or error out.
+    ///
+    /// If the item defined by `def_id` is unstable and the corresponding `#![feature]` does not
+    /// exist, emits an error.
+    ///
+    /// This function will also check if the item is deprecated.
+    /// If so, and `id` is not `None`, a deprecated lint attached to `id` will be emitted.
+    ///
+    /// Pass `EvalOverride::AllowUnstable` to `eval_override` to force an unstable item to be allowed. Deprecation warnings will be emitted normally.
+    pub fn check_stability_override(
+        self,
+        def_id: DefId,
+        id: Option<HirId>,
+        span: Span,
+        method_span: Option<Span>,
+        eval_override: EvalOverride,
+    ) {
+        self.check_optional_stability(
+            def_id,
+            id,
+            span,
+            method_span,
+            eval_override,
+            |span, def_id| {
+                // The API could be uncallable for other reasons, for example when a private module
+                // was referenced.
+                self.sess.delay_span_bug(span, &format!("encountered unmarked API: {:?}", def_id));
+            },
+        )
     }
 
     /// Like `check_stability`, except that we permit items to have custom behaviour for
@@ -462,14 +529,15 @@ impl<'tcx> TyCtxt<'tcx> {
         id: Option<HirId>,
         span: Span,
         method_span: Option<Span>,
+        eval_override: EvalOverride,
         unmarked: impl FnOnce(Span, DefId),
     ) {
         let soft_handler = |lint, span, msg: &_| {
             self.struct_span_lint_hir(lint, id.unwrap_or(hir::CRATE_HIR_ID), span, |lint| {
                 lint.build(msg).emit();
             })
         };
-        match self.eval_stability(def_id, id, span, method_span) {
+        match self.eval_stability_override(def_id, id, span, method_span, eval_override) {
             EvalResult::Allow => {}
             EvalResult::Deny { feature, reason, issue, suggestion, is_soft } => report_unstable(
                 self.sess,

compiler/rustc_passes/src/stability.rs

@@ -13,7 +13,7 @@ use rustc_hir::intravisit::{self, Visitor};
 use rustc_hir::{FieldDef, Generics, HirId, Item, TraitRef, Ty, TyKind, Variant};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::middle::privacy::AccessLevels;
-use rustc_middle::middle::stability::{DeprecationEntry, Index};
+use rustc_middle::middle::stability::{DeprecationEntry, EvalOverride, Index};
 use rustc_middle::ty::{self, query::Providers, TyCtxt};
 use rustc_session::lint;
 use rustc_session::lint::builtin::{INEFFECTIVE_UNSTABLE_TRAIT_IMPL, USELESS_DEPRECATED};
@@ -806,11 +806,19 @@ impl<'tcx> Visitor<'tcx> for Checker<'tcx> {
     }
 
     fn visit_path(&mut self, path: &'tcx hir::Path<'tcx>, id: hir::HirId) {
-        if !is_path_reexport(self.tcx, id) {
-            if let Some(def_id) = path.res.opt_def_id() {
-                let method_span = path.segments.last().map(|s| s.ident.span);
-                self.tcx.check_stability(def_id, Some(id), path.span, method_span)
-            }
+        if let Some(def_id) = path.res.opt_def_id() {
+            let method_span = path.segments.last().map(|s| s.ident.span);
+            self.tcx.check_stability_override(
+                def_id,
+                Some(id),
+                path.span,
+                method_span,
+                if is_path_reexport(self.tcx, id) {
+                    EvalOverride::AllowUnstable
+                } else {
+                    EvalOverride::None
+                },
+            )
         }
         intravisit::walk_path(self, path)
     }
@@ -826,6 +834,10 @@ fn is_path_reexport<'tcx>(tcx: TyCtxt<'tcx>, id: hir::HirId) -> bool {
         return false;
     }
 
+    if tcx.visibility(def_id) != ty::Visibility::Public {
+        return false;
+    }
+
     true
 }
 

compiler/rustc_typeck/src/astconv/mod.rs

@@ -426,6 +426,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
                             Some(arg.id()),
                             arg.span(),
                             None,
+                            Default::default(),
                             |_, _| {
                                 // Default generic parameters may not be marked
                                 // with stability attributes, i.e. when the

src/test/ui/stability-attribute/allow-unstable-reexport.rs

@@ -8,10 +8,12 @@
 extern crate lint_stability;
 extern crate lint_stability_reexport;
 
-use lint_stability::unstable;
+#[stable(feature = "lint_stability", since = "1.0.0")]
+pub use lint_stability::unstable;
 // We want to confirm that using a re-export through another crate behaves
 // the same way as using an item directly
-use lint_stability_reexport::unstable_text;
+#[stable(feature = "lint_stability", since = "1.0.0")]
+pub use lint_stability_reexport::unstable_text;
 
 fn main() {
     // Since we didn't enable the feature in this crate, we still can't

src/test/ui/stability-attribute/allow-unstable-reexport.stderr

@@ -1,13 +1,13 @@
 error[E0658]: use of unstable library feature 'unstable_test_feature'
-  --> $DIR/allow-unstable-reexport.rs:17:5
+  --> $DIR/allow-unstable-reexport.rs:21:5
    |
 LL |     unstable();
    |     ^^^^^^^^
    |
    = help: add `#![feature(unstable_test_feature)]` to the crate attributes to enable
 
 error[E0658]: use of unstable library feature 'unstable_test_feature': text
-  --> $DIR/allow-unstable-reexport.rs:18:5
+  --> $DIR/allow-unstable-reexport.rs:22:5
    |
 LL |     unstable_text();
    |     ^^^^^^^^^^^^^