core: add `#![warn(unreachable_pub)]`

17 files changed, 112 insertions, 104 deletions

diff --git a/library/core/src/array/mod.rs b/library/core/src/array/mod.rs
index 2ae5ded1fd5..ba61679564a 100644
--- a/library/core/src/array/mod.rs
+++ b/library/core/src/array/mod.rs
@@ -893,7 +893,7 @@ impl<T> Guard<'_, T> {
     ///
     /// No more than N elements must be initialized.
     #[inline]
-    pub unsafe fn push_unchecked(&mut self, item: T) {
+    pub(crate) unsafe fn push_unchecked(&mut self, item: T) {
         // SAFETY: If `initialized` was correct before and the caller does not
         // invoke this method more than N times then writes will be in-bounds
         // and slots will not be initialized more than once.
diff --git a/library/core/src/escape.rs b/library/core/src/escape.rs
index 0685f525dca..0c3329f676e 100644
--- a/library/core/src/escape.rs
+++ b/library/core/src/escape.rs
@@ -163,28 +163,28 @@ pub(crate) struct EscapeIterInner<const N: usize> {
 }
 
 impl<const N: usize> EscapeIterInner<N> {
-    pub const fn backslash(c: ascii::Char) -> Self {
+    pub(crate) const fn backslash(c: ascii::Char) -> Self {
         let (data, range) = backslash(c);
         Self { data, alive: range }
     }
 
-    pub const fn ascii(c: u8) -> Self {
+    pub(crate) const fn ascii(c: u8) -> Self {
         let (data, range) = escape_ascii(c);
         Self { data, alive: range }
     }
 
-    pub const fn unicode(c: char) -> Self {
+    pub(crate) const fn unicode(c: char) -> Self {
         let (data, range) = escape_unicode(c);
         Self { data, alive: range }
     }
 
     #[inline]
-    pub const fn empty() -> Self {
+    pub(crate) const fn empty() -> Self {
         Self { data: [ascii::Char::Null; N], alive: 0..0 }
     }
 
     #[inline]
-    pub fn as_ascii(&self) -> &[ascii::Char] {
+    pub(crate) fn as_ascii(&self) -> &[ascii::Char] {
         // SAFETY: `self.alive` is guaranteed to be a valid range for indexing `self.data`.
         unsafe {
             self.data.get_unchecked(usize::from(self.alive.start)..usize::from(self.alive.end))
@@ -192,34 +192,34 @@ impl<const N: usize> EscapeIterInner<N> {
     }
 
     #[inline]
-    pub fn as_str(&self) -> &str {
+    pub(crate) fn as_str(&self) -> &str {
         self.as_ascii().as_str()
     }
 
     #[inline]
-    pub fn len(&self) -> usize {
+    pub(crate) fn len(&self) -> usize {
         usize::from(self.alive.end - self.alive.start)
     }
 
-    pub fn next(&mut self) -> Option<u8> {
+    pub(crate) fn next(&mut self) -> Option<u8> {
         let i = self.alive.next()?;
 
         // SAFETY: `i` is guaranteed to be a valid index for `self.data`.
         unsafe { Some(self.data.get_unchecked(usize::from(i)).to_u8()) }
     }
 
-    pub fn next_back(&mut self) -> Option<u8> {
+    pub(crate) fn next_back(&mut self) -> Option<u8> {
         let i = self.alive.next_back()?;
 
         // SAFETY: `i` is guaranteed to be a valid index for `self.data`.
         unsafe { Some(self.data.get_unchecked(usize::from(i)).to_u8()) }
     }
 
-    pub fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
+    pub(crate) fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
         self.alive.advance_by(n)
     }
 
-    pub fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
+    pub(crate) fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
         self.alive.advance_back_by(n)
     }
 }
diff --git a/library/core/src/ffi/mod.rs b/library/core/src/ffi/mod.rs
index 5f32775822b..79d094556c4 100644
--- a/library/core/src/ffi/mod.rs
+++ b/library/core/src/ffi/mod.rs
@@ -172,10 +172,10 @@ mod c_char_definition {
                 target_arch = "xtensa",
             )
         ))] {
-            pub type c_char = u8;
+            pub(super) type c_char = u8;
         } else {
             // On every other target, c_char is signed.
-            pub type c_char = i8;
+            pub(super) type c_char = i8;
         }
     }
 }
@@ -183,11 +183,11 @@ mod c_char_definition {
 mod c_int_definition {
     cfg_if! {
         if #[cfg(any(target_arch = "avr", target_arch = "msp430"))] {
-            pub type c_int = i16;
-            pub type c_uint = u16;
+            pub(super) type c_int = i16;
+            pub(super) type c_uint = u16;
         } else {
-            pub type c_int = i32;
-            pub type c_uint = u32;
+            pub(super) type c_int = i32;
+            pub(super) type c_uint = u32;
         }
     }
 }
@@ -195,12 +195,12 @@ mod c_int_definition {
 mod c_long_definition {
     cfg_if! {
         if #[cfg(all(target_pointer_width = "64", not(windows)))] {
-            pub type c_long = i64;
-            pub type c_ulong = u64;
+            pub(super) type c_long = i64;
+            pub(super) type c_ulong = u64;
         } else {
             // The minimal size of `long` in the C standard is 32 bits
-            pub type c_long = i32;
-            pub type c_ulong = u32;
+            pub(super) type c_long = i32;
+            pub(super) type c_ulong = u32;
         }
     }
 }
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index e845bb34426..f58eab3b1b1 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -101,6 +101,7 @@
 #![warn(multiple_supertrait_upcastable)]
 #![allow(internal_features)]
 #![deny(ffi_unwind_calls)]
+#![warn(unreachable_pub)]
 // Do not check link redundancy on bootstraping phase
 #![allow(rustdoc::redundant_explicit_links)]
 #![warn(rustdoc::unescaped_backticks)]
@@ -396,7 +397,8 @@ pub mod primitive;
     unused_imports,
     unsafe_op_in_unsafe_fn,
     ambiguous_glob_reexports,
-    deprecated_in_future
+    deprecated_in_future,
+    unreachable_pub
 )]
 #[allow(rustdoc::bare_urls)]
 mod core_arch;
diff --git a/library/core/src/net/display_buffer.rs b/library/core/src/net/display_buffer.rs
index a7d12217081..625ad5401f5 100644
--- a/library/core/src/net/display_buffer.rs
+++ b/library/core/src/net/display_buffer.rs
@@ -2,19 +2,19 @@ use crate::mem::MaybeUninit;
 use crate::{fmt, str};
 
 /// Used for slow path in `Display` implementations when alignment is required.
-pub struct DisplayBuffer<const SIZE: usize> {
+pub(super) struct DisplayBuffer<const SIZE: usize> {
     buf: [MaybeUninit<u8>; SIZE],
     len: usize,
 }
 
 impl<const SIZE: usize> DisplayBuffer<SIZE> {
     #[inline]
-    pub const fn new() -> Self {
+    pub(super) const fn new() -> Self {
         Self { buf: [MaybeUninit::uninit(); SIZE], len: 0 }
     }
 
     #[inline]
-    pub fn as_str(&self) -> &str {
+    pub(super) fn as_str(&self) -> &str {
         // SAFETY: `buf` is only written to by the `fmt::Write::write_str` implementation
         // which writes a valid UTF-8 string to `buf` and correctly sets `len`.
         unsafe {
diff --git a/library/core/src/num/dec2flt/decimal.rs b/library/core/src/num/dec2flt/decimal.rs
index be9c0eccd5e..b37724ba62d 100644
--- a/library/core/src/num/dec2flt/decimal.rs
+++ b/library/core/src/num/dec2flt/decimal.rs
@@ -12,7 +12,7 @@
 use crate::num::dec2flt::common::{ByteSlice, is_8digits};
 
 #[derive(Clone)]
-pub struct Decimal {
+pub(super) struct Decimal {
     /// The number of significant digits in the decimal.
     pub num_digits: usize,
     /// The offset of the decimal point in the significant digits.
@@ -55,13 +55,13 @@ impl Decimal {
     ///
     /// In Python:
     ///     `-emin + p2 + math.floor((emin+ 1)*math.log(2, b)-math.log(1-2**(-p2), b))`
-    pub const MAX_DIGITS: usize = 768;
+    pub(super) const MAX_DIGITS: usize = 768;
     /// The max digits that can be exactly represented in a 64-bit integer.
-    pub const MAX_DIGITS_WITHOUT_OVERFLOW: usize = 19;
-    pub const DECIMAL_POINT_RANGE: i32 = 2047;
+    pub(super) const MAX_DIGITS_WITHOUT_OVERFLOW: usize = 19;
+    pub(super) const DECIMAL_POINT_RANGE: i32 = 2047;
 
     /// Append a digit to the buffer.
-    pub fn try_add_digit(&mut self, digit: u8) {
+    pub(super) fn try_add_digit(&mut self, digit: u8) {
         if self.num_digits < Self::MAX_DIGITS {
             self.digits[self.num_digits] = digit;
         }
@@ -69,7 +69,7 @@ impl Decimal {
     }
 
     /// Trim trailing zeros from the buffer.
-    pub fn trim(&mut self) {
+    pub(super) fn trim(&mut self) {
         // All of the following calls to `Decimal::trim` can't panic because:
         //
         //  1. `parse_decimal` sets `num_digits` to a max of `Decimal::MAX_DIGITS`.
@@ -83,7 +83,7 @@ impl Decimal {
         }
     }
 
-    pub fn round(&self) -> u64 {
+    pub(super) fn round(&self) -> u64 {
         if self.num_digits == 0 || self.decimal_point < 0 {
             return 0;
         } else if self.decimal_point > 18 {
@@ -111,7 +111,7 @@ impl Decimal {
     }
 
     /// Computes decimal * 2^shift.
-    pub fn left_shift(&mut self, shift: usize) {
+    pub(super) fn left_shift(&mut self, shift: usize) {
         if self.num_digits == 0 {
             return;
         }
@@ -152,7 +152,7 @@ impl Decimal {
     }
 
     /// Computes decimal * 2^-shift.
-    pub fn right_shift(&mut self, shift: usize) {
+    pub(super) fn right_shift(&mut self, shift: usize) {
         let mut read_index = 0;
         let mut write_index = 0;
         let mut n = 0_u64;
@@ -202,7 +202,7 @@ impl Decimal {
 }
 
 /// Parse a big integer representation of the float as a decimal.
-pub fn parse_decimal(mut s: &[u8]) -> Decimal {
+pub(super) fn parse_decimal(mut s: &[u8]) -> Decimal {
     let mut d = Decimal::default();
     let start = s;
 
diff --git a/library/core/src/num/dec2flt/fpu.rs b/library/core/src/num/dec2flt/fpu.rs
index 8d62684f8d3..daeee1755b0 100644
--- a/library/core/src/num/dec2flt/fpu.rs
+++ b/library/core/src/num/dec2flt/fpu.rs
@@ -1,7 +1,7 @@
 //! Platform-specific, assembly instructions to avoid
 //! intermediate rounding on architectures with FPUs.
 
-pub use fpu_precision::set_precision;
+pub(super) use fpu_precision::set_precision;
 
 // On x86, the x87 FPU is used for float operations if the SSE/SSE2 extensions are not available.
 // The x87 FPU operates with 80 bits of precision by default, which means that operations will
@@ -42,7 +42,7 @@ mod fpu_precision {
     ///  - 0b10, double precision i.e., 64-bits
     ///  - 0b11, double extended precision i.e., 80-bits (default state)
     /// The 0b01 value is reserved and should not be used.
-    pub struct FPUControlWord(u16);
+    pub(crate) struct FPUControlWord(u16);
 
     fn set_cw(cw: u16) {
         // SAFETY: the `fldcw` instruction has been audited to be able to work correctly with
@@ -57,7 +57,7 @@ mod fpu_precision {
     }
 
     /// Sets the precision field of the FPU to `T` and returns a `FPUControlWord`.
-    pub fn set_precision<T>() -> FPUControlWord {
+    pub(crate) fn set_precision<T>() -> FPUControlWord {
         let mut cw = 0_u16;
 
         // Compute the value for the Precision Control field that is appropriate for `T`.
@@ -97,5 +97,5 @@ mod fpu_precision {
 // precision of the computation is determined on a per-operation basis.
 #[cfg(any(not(target_arch = "x86"), target_feature = "sse2"))]
 mod fpu_precision {
-    pub fn set_precision<T>() {}
+    pub(crate) fn set_precision<T>() {}
 }
diff --git a/library/core/src/num/dec2flt/table.rs b/library/core/src/num/dec2flt/table.rs
index 4856074a62b..942c2eacfd2 100644
--- a/library/core/src/num/dec2flt/table.rs
+++ b/library/core/src/num/dec2flt/table.rs
@@ -6,16 +6,17 @@
 //!
 //! DO NOT MODIFY: Generated by `src/etc/dec2flt_table.py`
 
-pub const SMALLEST_POWER_OF_FIVE: i32 = -342;
-pub const LARGEST_POWER_OF_FIVE: i32 = 308;
-pub const N_POWERS_OF_FIVE: usize = (LARGEST_POWER_OF_FIVE - SMALLEST_POWER_OF_FIVE + 1) as usize;
+pub(super) const SMALLEST_POWER_OF_FIVE: i32 = -342;
+pub(super) const LARGEST_POWER_OF_FIVE: i32 = 308;
+pub(super) const N_POWERS_OF_FIVE: usize =
+    (LARGEST_POWER_OF_FIVE - SMALLEST_POWER_OF_FIVE + 1) as usize;
 
 // Use static to avoid long compile times: Rust compiler errors
 // can have the entire table compiled multiple times, and then
 // emit code multiple times, even if it's stripped out in
 // the final binary.
 #[rustfmt::skip]
-pub static POWER_OF_FIVE_128: [(u64, u64); N_POWERS_OF_FIVE] = [
+pub(super) static POWER_OF_FIVE_128: [(u64, u64); N_POWERS_OF_FIVE] = [
     (0xeef453d6923bd65a, 0x113faa2906a13b3f), // 5^-342
     (0x9558b4661b6565f8, 0x4ac7ca59a424c507), // 5^-341
     (0xbaaee17fa23ebf76, 0x5d79bcf00d2df649), // 5^-340
diff --git a/library/core/src/num/int_log10.rs b/library/core/src/num/int_log10.rs
index 0ce31b40a38..28a3f5d880a 100644
--- a/library/core/src/num/int_log10.rs
+++ b/library/core/src/num/int_log10.rs
@@ -3,7 +3,7 @@
 
 // 0 < val <= u8::MAX
 #[inline]
-pub const fn u8(val: u8) -> u32 {
+pub(super) const fn u8(val: u8) -> u32 {
     let val = val as u32;
 
     // For better performance, avoid branches by assembling the solution
@@ -45,13 +45,13 @@ const fn less_than_5(val: u32) -> u32 {
 
 // 0 < val <= u16::MAX
 #[inline]
-pub const fn u16(val: u16) -> u32 {
+pub(super) const fn u16(val: u16) -> u32 {
     less_than_5(val as u32)
 }
 
 // 0 < val <= u32::MAX
 #[inline]
-pub const fn u32(mut val: u32) -> u32 {
+pub(super) const fn u32(mut val: u32) -> u32 {
     let mut log = 0;
     if val >= 100_000 {
         val /= 100_000;
@@ -62,7 +62,7 @@ pub const fn u32(mut val: u32) -> u32 {
 
 // 0 < val <= u64::MAX
 #[inline]
-pub const fn u64(mut val: u64) -> u32 {
+pub(super) const fn u64(mut val: u64) -> u32 {
     let mut log = 0;
     if val >= 10_000_000_000 {
         val /= 10_000_000_000;
@@ -77,7 +77,7 @@ pub const fn u64(mut val: u64) -> u32 {
 
 // 0 < val <= u128::MAX
 #[inline]
-pub const fn u128(mut val: u128) -> u32 {
+pub(super) const fn u128(mut val: u128) -> u32 {
     let mut log = 0;
     if val >= 100_000_000_000_000_000_000_000_000_000_000 {
         val /= 100_000_000_000_000_000_000_000_000_000_000;
@@ -93,49 +93,49 @@ pub const fn u128(mut val: u128) -> u32 {
 
 #[cfg(target_pointer_width = "16")]
 #[inline]
-pub const fn usize(val: usize) -> u32 {
+pub(super) const fn usize(val: usize) -> u32 {
     u16(val as _)
 }
 
 #[cfg(target_pointer_width = "32")]
 #[inline]
-pub const fn usize(val: usize) -> u32 {
+pub(super) const fn usize(val: usize) -> u32 {
     u32(val as _)
 }
 
 #[cfg(target_pointer_width = "64")]
 #[inline]
-pub const fn usize(val: usize) -> u32 {
+pub(super) const fn usize(val: usize) -> u32 {
     u64(val as _)
 }
 
 // 0 < val <= i8::MAX
 #[inline]
-pub const fn i8(val: i8) -> u32 {
+pub(super) const fn i8(val: i8) -> u32 {
     u8(val as u8)
 }
 
 // 0 < val <= i16::MAX
 #[inline]
-pub const fn i16(val: i16) -> u32 {
+pub(super) const fn i16(val: i16) -> u32 {
     u16(val as u16)
 }
 
 // 0 < val <= i32::MAX
 #[inline]
-pub const fn i32(val: i32) -> u32 {
+pub(super) const fn i32(val: i32) -> u32 {
     u32(val as u32)
 }
 
 // 0 < val <= i64::MAX
 #[inline]
-pub const fn i64(val: i64) -> u32 {
+pub(super) const fn i64(val: i64) -> u32 {
     u64(val as u64)
 }
 
 // 0 < val <= i128::MAX
 #[inline]
-pub const fn i128(val: i128) -> u32 {
+pub(super) const fn i128(val: i128) -> u32 {
     u128(val as u128)
 }
 
@@ -143,6 +143,6 @@ pub const fn i128(val: i128) -> u32 {
 /// on every single primitive type.
 #[cold]
 #[track_caller]
-pub const fn panic_for_nonpositive_argument() -> ! {
+pub(super) const fn panic_for_nonpositive_argument() -> ! {
     panic!("argument of integer logarithm must be positive")
 }
diff --git a/library/core/src/num/int_sqrt.rs b/library/core/src/num/int_sqrt.rs
index 601e81f6993..c7a322c08c1 100644
--- a/library/core/src/num/int_sqrt.rs
+++ b/library/core/src/num/int_sqrt.rs
@@ -37,7 +37,7 @@ const U8_ISQRT_WITH_REMAINDER: [(u8, u8); 256] = {
 #[must_use = "this returns the result of the operation, \
               without modifying the original"]
 #[inline]
-pub const fn u8(n: u8) -> u8 {
+pub(super) const fn u8(n: u8) -> u8 {
     U8_ISQRT_WITH_REMAINDER[n as usize].0
 }
 
@@ -58,7 +58,7 @@ macro_rules! signed_fn {
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
-        pub const unsafe fn $SignedT(n: $SignedT) -> $SignedT {
+        pub(super) const unsafe fn $SignedT(n: $SignedT) -> $SignedT {
             debug_assert!(n >= 0, "Negative input inside `isqrt`.");
             $UnsignedT(n as $UnsignedT) as $SignedT
         }
@@ -83,7 +83,7 @@ macro_rules! unsigned_fn {
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
-        pub const fn $UnsignedT(mut n: $UnsignedT) -> $UnsignedT {
+        pub(super) const fn $UnsignedT(mut n: $UnsignedT) -> $UnsignedT {
             if n <= <$HalfBitsT>::MAX as $UnsignedT {
                 $HalfBitsT(n as $HalfBitsT) as $UnsignedT
             } else {
@@ -311,6 +311,6 @@ unsigned_fn!(u128, u64, u128_stages);
 /// on every single primitive type.
 #[cold]
 #[track_caller]
-pub const fn panic_for_negative_argument() -> ! {
+pub(super) const fn panic_for_negative_argument() -> ! {
     panic!("argument of integer square root cannot be negative")
 }
diff --git a/library/core/src/num/overflow_panic.rs b/library/core/src/num/overflow_panic.rs
index 203037ffb43..e30573dd3f3 100644
--- a/library/core/src/num/overflow_panic.rs
+++ b/library/core/src/num/overflow_panic.rs
@@ -4,48 +4,48 @@
 
 #[cold]
 #[track_caller]
-pub const fn add() -> ! {
+pub(super) const fn add() -> ! {
     panic!("attempt to add with overflow")
 }
 
 #[cold]
 #[track_caller]
-pub const fn sub() -> ! {
+pub(super) const fn sub() -> ! {
     panic!("attempt to subtract with overflow")
 }
 
 #[cold]
 #[track_caller]
-pub const fn mul() -> ! {
+pub(super) const fn mul() -> ! {
     panic!("attempt to multiply with overflow")
 }
 
 #[cold]
 #[track_caller]
-pub const fn div() -> ! {
+pub(super) const fn div() -> ! {
     panic!("attempt to divide with overflow")
 }
 
 #[cold]
 #[track_caller]
-pub const fn rem() -> ! {
+pub(super) const fn rem() -> ! {
     panic!("attempt to calculate the remainder with overflow")
 }
 
 #[cold]
 #[track_caller]
-pub const fn neg() -> ! {
+pub(super) const fn neg() -> ! {
     panic!("attempt to negate with overflow")
 }
 
 #[cold]
 #[track_caller]
-pub const fn shr() -> ! {
+pub(super) const fn shr() -> ! {
     panic!("attempt to shift right with overflow")
 }
 
 #[cold]
 #[track_caller]
-pub const fn shl() -> ! {
+pub(super) const fn shl() -> ! {
     panic!("attempt to shift left with overflow")
 }
diff --git a/library/core/src/num/wrapping.rs b/library/core/src/num/wrapping.rs
index 1156b389e28..55fa91d0b9f 100644
--- a/library/core/src/num/wrapping.rs
+++ b/library/core/src/num/wrapping.rs
@@ -1058,33 +1058,33 @@ mod shift_max {
 
     #[cfg(target_pointer_width = "16")]
     mod platform {
-        pub const usize: u32 = super::u16;
-        pub const isize: u32 = super::i16;
+        pub(crate) const usize: u32 = super::u16;
+        pub(crate) const isize: u32 = super::i16;
     }
 
     #[cfg(target_pointer_width = "32")]
     mod platform {
-        pub const usize: u32 = super::u32;
-        pub const isize: u32 = super::i32;
+        pub(crate) const usize: u32 = super::u32;
+        pub(crate) const isize: u32 = super::i32;
     }
 
     #[cfg(target_pointer_width = "64")]
     mod platform {
-        pub const usize: u32 = super::u64;
-        pub const isize: u32 = super::i64;
+        pub(crate) const usize: u32 = super::u64;
+        pub(crate) const isize: u32 = super::i64;
     }
 
-    pub const i8: u32 = (1 << 3) - 1;
-    pub const i16: u32 = (1 << 4) - 1;
-    pub const i32: u32 = (1 << 5) - 1;
-    pub const i64: u32 = (1 << 6) - 1;
-    pub const i128: u32 = (1 << 7) - 1;
-    pub use self::platform::isize;
-
-    pub const u8: u32 = i8;
-    pub const u16: u32 = i16;
-    pub const u32: u32 = i32;
-    pub const u64: u32 = i64;
-    pub const u128: u32 = i128;
-    pub use self::platform::usize;
+    pub(super) const i8: u32 = (1 << 3) - 1;
+    pub(super) const i16: u32 = (1 << 4) - 1;
+    pub(super) const i32: u32 = (1 << 5) - 1;
+    pub(super) const i64: u32 = (1 << 6) - 1;
+    pub(super) const i128: u32 = (1 << 7) - 1;
+    pub(super) use self::platform::isize;
+
+    pub(super) const u8: u32 = i8;
+    pub(super) const u16: u32 = i16;
+    pub(super) const u32: u32 = i32;
+    pub(super) const u64: u32 = i64;
+    pub(super) const u128: u32 = i128;
+    pub(super) use self::platform::usize;
 }
diff --git a/library/core/src/ops/index_range.rs b/library/core/src/ops/index_range.rs
index dce3514a159..b82184b15b2 100644
--- a/library/core/src/ops/index_range.rs
+++ b/library/core/src/ops/index_range.rs
@@ -18,7 +18,7 @@ impl IndexRange {
     /// # Safety
     /// - `start <= end`
     #[inline]
-    pub const unsafe fn new_unchecked(start: usize, end: usize) -> Self {
+    pub(crate) const unsafe fn new_unchecked(start: usize, end: usize) -> Self {
         ub_checks::assert_unsafe_precondition!(
             check_library_ub,
             "IndexRange::new_unchecked requires `start <= end`",
@@ -28,22 +28,22 @@ impl IndexRange {
     }
 
     #[inline]
-    pub const fn zero_to(end: usize) -> Self {
+    pub(crate) const fn zero_to(end: usize) -> Self {
         IndexRange { start: 0, end }
     }
 
     #[inline]
-    pub const fn start(&self) -> usize {
+    pub(crate) const fn start(&self) -> usize {
         self.start
     }
 
     #[inline]
-    pub const fn end(&self) -> usize {
+    pub(crate) const fn end(&self) -> usize {
         self.end
     }
 
     #[inline]
-    pub const fn len(&self) -> usize {
+    pub(crate) const fn len(&self) -> usize {
         // SAFETY: By invariant, this cannot wrap
         // Using the intrinsic because a UB check here impedes LLVM optimization. (#131563)
         unsafe { crate::intrinsics::unchecked_sub(self.end, self.start) }
@@ -79,7 +79,7 @@ impl IndexRange {
     ///
     /// This is designed to help implement `Iterator::advance_by`.
     #[inline]
-    pub fn take_prefix(&mut self, n: usize) -> Self {
+    pub(crate) fn take_prefix(&mut self, n: usize) -> Self {
         let mid = if n <= self.len() {
             // SAFETY: We just checked that this will be between start and end,
             // and thus the addition cannot overflow.
@@ -99,7 +99,7 @@ impl IndexRange {
     ///
     /// This is designed to help implement `Iterator::advance_back_by`.
     #[inline]
-    pub fn take_suffix(&mut self, n: usize) -> Self {
+    pub(crate) fn take_suffix(&mut self, n: usize) -> Self {
         let mid = if n <= self.len() {
             // SAFETY: We just checked that this will be between start and end,
             // and thus the subtraction cannot overflow.
diff --git a/library/core/src/ops/try_trait.rs b/library/core/src/ops/try_trait.rs
index cd444c86ed0..3ba2957526f 100644
--- a/library/core/src/ops/try_trait.rs
+++ b/library/core/src/ops/try_trait.rs
@@ -338,6 +338,7 @@ pub trait FromResidual<R = <Self as Try>::Residual> {
 #[inline]
 #[track_caller] // because `Result::from_residual` has it
 #[lang = "from_yeet"]
+#[allow(unreachable_pub)] // not-exposed but still used via lang-item
 pub fn from_yeet<T, Y>(yeeted: Y) -> T
 where
     T: FromResidual<Yeet<Y>>,
@@ -383,12 +384,14 @@ impl<T> NeverShortCircuit<T> {
     /// This is useful for implementing infallible functions in terms of the `try_` ones,
     /// without accidentally capturing extra generic parameters in a closure.
     #[inline]
-    pub fn wrap_mut_1<A>(mut f: impl FnMut(A) -> T) -> impl FnMut(A) -> NeverShortCircuit<T> {
+    pub(crate) fn wrap_mut_1<A>(
+        mut f: impl FnMut(A) -> T,
+    ) -> impl FnMut(A) -> NeverShortCircuit<T> {
         move |a| NeverShortCircuit(f(a))
     }
 
     #[inline]
-    pub fn wrap_mut_2<A, B>(mut f: impl FnMut(A, B) -> T) -> impl FnMut(A, B) -> Self {
+    pub(crate) fn wrap_mut_2<A, B>(mut f: impl FnMut(A, B) -> T) -> impl FnMut(A, B) -> Self {
         move |a, b| NeverShortCircuit(f(a, b))
     }
 }
diff --git a/library/core/src/slice/rotate.rs b/library/core/src/slice/rotate.rs
index 1e4865a7caa..d8e0acb565c 100644
--- a/library/core/src/slice/rotate.rs
+++ b/library/core/src/slice/rotate.rs
@@ -60,7 +60,7 @@ use crate::{cmp, ptr};
 /// we cannot swap any more, but a smaller rotation problem is left to solve
 /// ```
 /// when `left < right` the swapping happens from the left instead.
-pub unsafe fn ptr_rotate<T>(mut left: usize, mut mid: *mut T, mut right: usize) {
+pub(super) unsafe fn ptr_rotate<T>(mut left: usize, mut mid: *mut T, mut right: usize) {
     type BufType = [usize; 32];
     if T::IS_ZST {
         return;
diff --git a/library/core/src/unicode/mod.rs b/library/core/src/unicode/mod.rs
index 6066aa99216..49dbdeb1a6d 100644
--- a/library/core/src/unicode/mod.rs
+++ b/library/core/src/unicode/mod.rs
@@ -17,6 +17,8 @@ pub(crate) use unicode_data::uppercase::lookup as Uppercase;
 pub(crate) use unicode_data::white_space::lookup as White_Space;
 
 pub(crate) mod printable;
+
+#[allow(unreachable_pub)]
 mod unicode_data;
 
 /// The version of [Unicode](https://www.unicode.org/) that the Unicode parts of
diff --git a/src/etc/dec2flt_table.py b/src/etc/dec2flt_table.py
index 791186de9c1..ecfdacc1f31 100755
--- a/src/etc/dec2flt_table.py
+++ b/src/etc/dec2flt_table.py
@@ -43,10 +43,10 @@ def main():
 
     print(HEADER.strip())
     print()
-    print("pub const SMALLEST_POWER_OF_FIVE: i32 = {};".format(min_exp))
-    print("pub const LARGEST_POWER_OF_FIVE: i32 = {};".format(max_exp))
-    print("pub const N_POWERS_OF_FIVE: usize = ", end="")
-    print("(LARGEST_POWER_OF_FIVE - SMALLEST_POWER_OF_FIVE + 1) as usize;")
+    print("pub(super) const SMALLEST_POWER_OF_FIVE: i32 = {};".format(min_exp))
+    print("pub(super) const LARGEST_POWER_OF_FIVE: i32 = {};".format(max_exp))
+    print("pub(super) const N_POWERS_OF_FIVE: usize =")
+    print("    (LARGEST_POWER_OF_FIVE - SMALLEST_POWER_OF_FIVE + 1) as usize;")
     print()
     print_proper_powers(min_exp, max_exp, bias)
 
@@ -97,7 +97,7 @@ def print_proper_powers(min_exp, max_exp, bias):
     print(STATIC_WARNING.strip())
     print("#[rustfmt::skip]")
     typ = "[(u64, u64); N_POWERS_OF_FIVE]"
-    print("pub static POWER_OF_FIVE_128: {} = [".format(typ))
+    print("pub(super) static POWER_OF_FIVE_128: {} = [".format(typ))
     for c, exp in powers:
         hi = "0x{:x}".format(c // (1 << 64))
         lo = "0x{:x}".format(c % (1 << 64))