Enable type privacy lints in rustc

Author: Bryanskiy

compiler/rustc_privacy/src/lib.rs

@@ -1939,7 +1939,7 @@ impl<'tcx> PrivateItemsInPublicInterfacesChecker<'tcx, '_> {
         let reexported_at_vis = effective_vis.at_level(Level::Reexported);
         let reachable_at_vis = effective_vis.at_level(Level::Reachable);
 
-        if reexported_at_vis != reachable_at_vis {
+        if reachable_at_vis.is_public() && reexported_at_vis != reachable_at_vis {
             let hir_id = self.tcx.hir().local_def_id_to_hir_id(def_id);
             let span = self.tcx.def_span(def_id.to_def_id());
             self.tcx.emit_spanned_lint(
@@ -1971,10 +1971,6 @@ impl<'tcx> PrivateItemsInPublicInterfacesChecker<'tcx, '_> {
             AssocItemKind::Type => (self.tcx.defaultness(def_id).has_value(), true),
         };
 
-        if is_assoc_ty {
-            self.check_unnameable(def_id, self.get(def_id));
-        }
-
         check.in_assoc_ty = is_assoc_ty;
         check.generics().predicates();
         if check_ty {

library/alloc/src/slice.rs

@@ -111,6 +111,8 @@ pub(crate) mod hack {
         T::to_vec(s, alloc)
     }
 
+    #[allow(unnameable_types)]
+    //~^ reachable at visibility `pub`, but can only be named at visibility `pub(crate)`
     #[cfg(not(no_global_oom_handling))]
     pub trait ConvertVec {
         fn to_vec<A: Allocator>(s: &[Self], alloc: A) -> Vec<Self, A>

library/alloc/src/vec/into_iter.rs

@@ -360,6 +360,8 @@ where
     }
 }
 
+#[allow(unnameable_types)]
+//~^ reachable at visibility `pub`, but can only be named at visibility `pub(vec)`
 #[doc(hidden)]
 #[unstable(issue = "none", feature = "std_internals")]
 #[rustc_unsafe_specialization_marker]

library/core/src/array/drain.rs

@@ -29,6 +29,8 @@ pub(crate) fn drain_array_with<T, R, const N: usize>(
 /// See [`drain_array_with`] -- this is `pub(crate)` only so it's allowed to be
 /// mentioned in the signature of that method.  (Otherwise it hits `E0446`.)
 // INVARIANT: It's ok to drop the remainder of the inner iterator.
+#[cfg_attr(bootstrap, allow(unnameable_types))]
+//~^ reachable at visibility `pub(crate)`, but can only be named at visibility `pub(array)`
 pub(crate) struct Drain<'a, T>(slice::IterMut<'a, T>);
 
 impl<T> Drop for Drain<'_, T> {
@@ -39,6 +41,8 @@ impl<T> Drop for Drain<'_, T> {
 }
 
 impl<T> Iterator for Drain<'_, T> {
+    #[cfg_attr(bootstrap, allow(unnameable_types))]
+    //~^ reachable at visibility `pub(crate)`, but can only be named at visibility `pub(array)`
     type Item = T;
 
     #[inline]

library/core/src/convert/num.rs

@@ -5,6 +5,8 @@ mod private {
     /// This trait being unreachable from outside the crate
     /// prevents other implementations of the `FloatToInt` trait,
     /// which allows potentially adding more trait methods after the trait is `#[stable]`.
+    #[allow(unnameable_types)]
+    //~^ reachable at visibility `pub`, but can only be named at visibility `pub(num)`
     #[unstable(feature = "convert_float_to_int", issue = "67057")]
     pub trait Sealed {}
 }

library/core/src/error.rs

@@ -207,6 +207,8 @@ where
 mod private {
     // This is a hack to prevent `type_id` from being overridden by `Error`
     // implementations, since that can enable unsound downcasting.
+    #[allow(unnameable_types)]
+    //~^ reachable at visibility `pub`, but can only be named at visibility `pub(error)`
     #[unstable(feature = "error_type_id", issue = "60784")]
     #[derive(Debug)]
     pub struct Internal;

library/core/src/ffi/mod.rs

@@ -522,6 +522,8 @@ impl<'a, 'f: 'a> DerefMut for VaList<'a, 'f> {
 // improving this.
 mod sealed_trait {
     /// Trait which permits the allowed types to be used with [super::VaListImpl::arg].
+    #[allow(unnameable_types)]
+    //~^ reachable at visibility `pub`, but can only be named at visibility `pub(ffi)`
     #[unstable(
         feature = "c_variadic",
         reason = "the `c_variadic` feature has not been properly tested on \

library/core/src/fmt/rt.rs

@@ -5,6 +5,8 @@
 
 use super::*;
 
+#[allow(unnameable_types)]
+//~^ reachable at visibility `pub`, but can only be named at visibility `pub(fmt)`
 #[lang = "format_placeholder"]
 #[derive(Copy, Clone)]
 pub struct Placeholder {
@@ -30,6 +32,8 @@ impl Placeholder {
     }
 }
 
+#[allow(unnameable_types)]
+//~^ reachable at visibility `pub`, but can only be named at visibility `pub(fmt)`
 #[lang = "format_alignment"]
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub enum Alignment {
@@ -41,6 +45,8 @@ pub enum Alignment {
 
 /// Used by [width](https://doc.rust-lang.org/std/fmt/#width)
 /// and [precision](https://doc.rust-lang.org/std/fmt/#precision) specifiers.
+#[allow(unnameable_types)]
+//~^ reachable at visibility `pub`, but can only be named at visibility `pub(fmt)`
 #[lang = "format_count"]
 #[derive(Copy, Clone)]
 pub enum Count {
@@ -70,6 +76,8 @@ pub(super) enum Flag {
 ///
 /// Argument is essentially an optimized partially applied formatting function,
 /// equivalent to `exists T.(&T, fn(&T, &mut Formatter<'_>) -> Result`.
+#[allow(unnameable_types)]
+//~^ reachable at visibility `pub`, but can only be named at visibility `pub(fmt)`
 #[lang = "format_argument"]
 #[derive(Copy, Clone)]
 pub struct Argument<'a> {
@@ -172,6 +180,8 @@ impl<'a> Argument<'a> {
 /// This struct represents the unsafety of constructing an `Arguments`.
 /// It exists, rather than an unsafe function, in order to simplify the expansion
 /// of `format_args!(..)` and reduce the scope of the `unsafe` block.
+#[allow(unnameable_types)]
+//~^ reachable at visibility `pub`, but can only be named at visibility `pub(fmt)`
 #[lang = "format_unsafe_arg"]
 pub struct UnsafeArg {
     _private: (),

library/core/src/future/join.rs

@@ -149,6 +149,8 @@ macro join_internal {
 /// be later taken and doesn't panic when polled after ready.
 ///
 /// This type is public in a private module for use by the macro.
+#[allow(unnameable_types)]
+//~^ reachable at visibility `pub`, but can only be named at visibility `pub(future)`
 #[allow(missing_debug_implementations)]
 #[unstable(feature = "future_join", issue = "91642")]
 pub enum MaybeDone<F: Future> {
@@ -172,6 +174,8 @@ impl<F: Future> MaybeDone<F> {
 
 #[unstable(feature = "future_join", issue = "91642")]
 impl<F: Future> Future for MaybeDone<F> {
+    #[cfg_attr(bootstrap, allow(unnameable_types))]
+    //~^ reachable at visibility `pub`, but can only be named at visibility `pub(future)`
     type Output = ();
 
     fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

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

@@ -145,6 +145,8 @@ pub unsafe trait SourceIter {
 ///
 /// If a `ControlFlow::Break` is encountered, the iterator stops and the
 /// residual is stored.
+#[cfg_attr(bootstrap, allow(unnameable_types))]
+//~^ reachable at visibility `pub(crate)`, but can only be named at visibility `pub(iter)`
 pub(crate) struct GenericShunt<'a, I, R> {
     iter: I,
     residual: &'a mut Option<R>,
@@ -172,6 +174,8 @@ impl<I, R> Iterator for GenericShunt<'_, I, R>
 where
     I: Iterator<Item: Try<Residual = R>>,
 {
+    #[cfg_attr(bootstrap, allow(unnameable_types))]
+    //~^ reachable at visibility `pub(crate)`, but can only be named at visibility `pub(iter)`
     type Item = <I::Item as Try>::Output;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -211,6 +215,8 @@ unsafe impl<I, R> SourceIter for GenericShunt<'_, I, R>
 where
     I: SourceIter,
 {
+    #[cfg_attr(bootstrap, allow(unnameable_types))]
+    //~^ reachable at visibility `pub(crate)`, but can only be named at visibility `pub(iter)`
     type Source = I::Source;
 
     #[inline]