Use generic NonZero internally.

compiler/rustc_attr/src/builtin.rs

@@ -13,7 +13,7 @@ use rustc_session::parse::feature_err;
 use rustc_session::{RustcVersion, Session};
 use rustc_span::hygiene::Transparency;
 use rustc_span::{symbol::sym, symbol::Symbol, Span};
-use std::num::NonZeroU32;
+use std::num::NonZero;
 
 use crate::session_diagnostics::{self, IncorrectReprFormatGenericCause};
 
@@ -113,7 +113,7 @@ pub enum StabilityLevel {
  /// Reason for the current stability level.
  reason: UnstableReason,
  /// Relevant `rust-lang/rust` issue.
- issue: Option<NonZeroU32>,
+ issue: Option<NonZero<u32>>,
  is_soft: bool,
  /// If part of a feature is stabilized and a new feature is added for the remaining parts,
  /// then the `implied_by` attribute is used to indicate which now-stable feature previously
@@ -442,7 +442,7 @@ fn parse_unstability(sess: &Session, attr: &Attribute) -> Option<(Symbol, Stabil
  // is a name/value pair string literal.
  issue_num = match issue.unwrap().as_str() {
  "none" => None,
- issue => match issue.parse::<NonZeroU32>() {
+ issue => match issue.parse::<NonZero<u32>>() {
  Ok(num) => Some(num),
  Err(err) => {
  sess.dcx().emit_err(

compiler/rustc_attr/src/lib.rs

@@ -7,6 +7,7 @@
 #![allow(internal_features)]
 #![feature(rustdoc_internals)]
 #![doc(rust_logo)]
+#![feature(generic_nonzero)]
 #![feature(let_chains)]
 
 #[macro_use]

compiler/rustc_const_eval/src/interpret/validity.rs

@@ -5,7 +5,7 @@
 //! to be const-safe.
 
 use std::fmt::Write;
-use std::num::NonZeroUsize;
+use std::num::NonZero;
 
 use either::{Left, Right};
 
@@ -782,7 +782,7 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValueVisitor<'mir, 'tcx, M>
  fn visit_union(
  &mut self,
  op: &OpTy<'tcx, M::Provenance>,
- _fields: NonZeroUsize,
+ _fields: NonZero<usize>,
  ) -> InterpResult<'tcx> {
  // Special check for CTFE validation, preventing `UnsafeCell` inside unions in immutable memory.
  if self.ctfe_mode.is_some_and(|c| !c.allow_immutable_unsafe_cell()) {

compiler/rustc_const_eval/src/interpret/visitor.rs

@@ -7,7 +7,7 @@ use rustc_middle::ty;
 use rustc_target::abi::FieldIdx;
 use rustc_target::abi::{FieldsShape, VariantIdx, Variants};
 
-use std::num::NonZeroUsize;
+use std::num::NonZero;
 
 use super::{InterpCx, MPlaceTy, Machine, Projectable};
 
@@ -43,7 +43,7 @@ pub trait ValueVisitor<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>>: Sized {
  }
  /// Visits the given value as a union. No automatic recursion can happen here.
  #[inline(always)]
- fn visit_union(&mut self, _v: &Self::V, _fields: NonZeroUsize) -> InterpResult<'tcx> {
+ fn visit_union(&mut self, _v: &Self::V, _fields: NonZero<usize>) -> InterpResult<'tcx> {
  Ok(())
  }
  /// Visits the given value as the pointer of a `Box`. There is nothing to recurse into.

compiler/rustc_const_eval/src/lib.rs

@@ -11,6 +11,7 @@ Rust MIR: a lowered representation of Rust.
 #![feature(assert_matches)]
 #![feature(box_patterns)]
 #![feature(decl_macro)]
+#![feature(generic_nonzero)]
 #![feature(let_chains)]
 #![feature(slice_ptr_get)]
 #![feature(never_type)]

compiler/rustc_data_structures/src/lib.rs

@@ -20,6 +20,7 @@
 #![feature(cfg_match)]
 #![feature(core_intrinsics)]
 #![feature(extend_one)]
+#![feature(generic_nonzero)]
 #![feature(hash_raw_entry)]
 #![feature(hasher_prefixfree_extras)]
 #![feature(lazy_cell)]

compiler/rustc_data_structures/src/stable_hasher.rs

@@ -6,6 +6,7 @@ use std::fmt;
 use std::hash::{BuildHasher, Hash, Hasher};
 use std::marker::PhantomData;
 use std::mem;
+use std::num::NonZero;
 
 #[cfg(test)]
 mod tests;
@@ -338,14 +339,14 @@ impl<CTX, T> HashStable<CTX> for PhantomData<T> {
  fn hash_stable(&self, _ctx: &mut CTX, _hasher: &mut StableHasher) {}
 }
 
-impl<CTX> HashStable<CTX> for ::std::num::NonZeroU32 {
+impl<CTX> HashStable<CTX> for NonZero<u32> {
  #[inline]
  fn hash_stable(&self, ctx: &mut CTX, hasher: &mut StableHasher) {
  self.get().hash_stable(ctx, hasher)
  }
 }
 
-impl<CTX> HashStable<CTX> for ::std::num::NonZeroUsize {
+impl<CTX> HashStable<CTX> for NonZero<usize> {
  #[inline]
  fn hash_stable(&self, ctx: &mut CTX, hasher: &mut StableHasher) {
  self.get().hash_stable(ctx, hasher)

compiler/rustc_data_structures/src/sync/worker_local.rs

@@ -1,7 +1,7 @@
 use parking_lot::Mutex;
 use std::cell::Cell;
 use std::cell::OnceCell;
-use std::num::NonZeroUsize;
+use std::num::NonZero;
 use std::ops::Deref;
 use std::ptr;
 use std::sync::Arc;
@@ -31,7 +31,7 @@ impl RegistryId {
 }
 
 struct RegistryData {
- thread_limit: NonZeroUsize,
+ thread_limit: NonZero<usize>,
  threads: Mutex<usize>,
 }
 
@@ -61,7 +61,7 @@ thread_local! {
 
 impl Registry {
  /// Creates a registry which can hold up to `thread_limit` threads.
- pub fn new(thread_limit: NonZeroUsize) -> Self {
+ pub fn new(thread_limit: NonZero<usize>) -> Self {
  Registry(Arc::new(RegistryData { thread_limit, threads: Mutex::new(0) }))
  }
 

compiler/rustc_data_structures/src/tagged_ptr/copy.rs

@@ -4,7 +4,7 @@ use std::fmt;
 use std::hash::{Hash, Hasher};
 use std::marker::PhantomData;
 use std::mem::ManuallyDrop;
-use std::num::NonZeroUsize;
+use std::num::NonZero;
 use std::ops::{Deref, DerefMut};
 use std::ptr::NonNull;
 
@@ -134,7 +134,7 @@ where
 
  ptr.map_addr(|addr| {
  // Safety:
- // - The pointer is `NonNull` => it's address is `NonZeroUsize`
+ // - The pointer is `NonNull` => it's address is `NonZero<usize>`
  // - `P::BITS` least significant bits are always zero (`Pointer` contract)
  // - `T::BITS <= P::BITS` (from `Self::ASSERTION`)
  //
@@ -143,14 +143,14 @@ where
  // `{non_zero} | packed_tag` can't make the value zero.
 
  let packed = (addr.get() >> T::BITS) | packed_tag;
- unsafe { NonZeroUsize::new_unchecked(packed) }
+ unsafe { NonZero::new_unchecked(packed) }
  })
  }
 
  /// Retrieves the original raw pointer from `self.packed`.
  #[inline]
  pub(super) fn pointer_raw(&self) -> NonNull<P::Target> {
- self.packed.map_addr(|addr| unsafe { NonZeroUsize::new_unchecked(addr.get() << T::BITS) })
+ self.packed.map_addr(|addr| unsafe { NonZero::new_unchecked(addr.get() << T::BITS) })
  }
 
  /// This provides a reference to the `P` pointer itself, rather than the

compiler/rustc_errors/src/diagnostic_impls.rs

@@ -79,7 +79,7 @@ into_diagnostic_arg_using_display!(
  ast::ParamKindOrd,
  std::io::Error,
  Box<dyn std::error::Error>,
- std::num::NonZeroU32,
+ std::num::NonZero<u32>,
  hir::Target,
  Edition,
  Ident,

compiler/rustc_errors/src/lib.rs

@@ -16,6 +16,7 @@
 #![feature(box_patterns)]
 #![feature(error_reporter)]
 #![feature(extract_if)]
+#![feature(generic_nonzero)]
 #![feature(let_chains)]
 #![feature(negative_impls)]
 #![feature(never_type)]
@@ -77,7 +78,7 @@ use std::error::Report;
 use std::fmt;
 use std::hash::Hash;
 use std::io::Write;
-use std::num::NonZeroUsize;
+use std::num::NonZero;
 use std::ops::DerefMut;
 use std::panic;
 use std::path::{Path, PathBuf};
@@ -545,7 +546,7 @@ pub struct DiagCtxtFlags {
  pub can_emit_warnings: bool,
  /// If Some, the Nth error-level diagnostic is upgraded to bug-level.
  /// (rustc: see `-Z treat-err-as-bug`)
- pub treat_err_as_bug: Option<NonZeroUsize>,
+ pub treat_err_as_bug: Option<NonZero<usize>>,
  /// Eagerly emit delayed bugs as errors, so that the compiler debugger may
  /// see all of the errors being emitted at once.
  pub eagerly_emit_delayed_bugs: bool,

compiler/rustc_feature/src/lib.rs

@@ -12,6 +12,7 @@
 //! symbol to the `accepted` or `removed` modules respectively.
 
 #![allow(internal_features)]
+#![feature(generic_nonzero)]
 #![feature(rustdoc_internals)]
 #![doc(rust_logo)]
 #![feature(lazy_cell)]
@@ -25,13 +26,13 @@ mod unstable;
 mod tests;
 
 use rustc_span::symbol::Symbol;
-use std::num::NonZeroU32;
+use std::num::NonZero;
 
 #[derive(Debug, Clone)]
 pub struct Feature {
  pub name: Symbol,
  pub since: &'static str,
- issue: Option<NonZeroU32>,
+ issue: Option<NonZero<u32>>,
 }
 
 #[derive(Copy, Clone, Debug)]
@@ -85,7 +86,7 @@ impl UnstableFeatures {
  }
 }
 
-fn find_lang_feature_issue(feature: Symbol) -> Option<NonZeroU32> {
+fn find_lang_feature_issue(feature: Symbol) -> Option<NonZero<u32>> {
  // Search in all the feature lists.
  if let Some(f) = UNSTABLE_FEATURES.iter().find(|f| f.feature.name == feature) {
  return f.feature.issue;
@@ -99,21 +100,21 @@ fn find_lang_feature_issue(feature: Symbol) -> Option<NonZeroU32> {
  panic!("feature `{feature}` is not declared anywhere");
 }
 
-const fn to_nonzero(n: Option<u32>) -> Option<NonZeroU32> {
- // Can be replaced with `n.and_then(NonZeroU32::new)` if that is ever usable
+const fn to_nonzero(n: Option<u32>) -> Option<NonZero<u32>> {
+ // Can be replaced with `n.and_then(NonZero::new)` if that is ever usable
  // in const context. Requires https:/rust-lang/rfcs/pull/2632.
  match n {
  None => None,
- Some(n) => NonZeroU32::new(n),
+ Some(n) => NonZero::new(n),
  }
 }
 
 pub enum GateIssue {
  Language,
- Library(Option<NonZeroU32>),
+ Library(Option<NonZero<u32>>),
 }
 
-pub fn find_feature_issue(feature: Symbol, issue: GateIssue) -> Option<NonZeroU32> {
+pub fn find_feature_issue(feature: Symbol, issue: GateIssue) -> Option<NonZero<u32>> {
  match issue {
  GateIssue::Language => find_lang_feature_issue(feature),
  GateIssue::Library(lib) => lib,

compiler/rustc_hir_analysis/src/check/mod.rs

@@ -74,7 +74,7 @@ pub mod wfcheck;
 
 pub use check::check_abi;
 
-use std::num::NonZeroU32;
+use std::num::NonZero;
 
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_errors::ErrorGuaranteed;
@@ -270,7 +270,7 @@ fn default_body_is_unstable(
  item_did: DefId,
  feature: Symbol,
  reason: Option<Symbol>,
- issue: Option<NonZeroU32>,
+ issue: Option<NonZero<u32>>,
 ) {
  let missing_item_name = tcx.associated_item(item_did).name;
  let (mut some_note, mut none_note, mut reason_str) = (false, false, String::new());

compiler/rustc_hir_analysis/src/lib.rs

@@ -63,6 +63,7 @@ This API is completely unstable and subject to change.
 #![feature(rustdoc_internals)]
 #![allow(internal_features)]
 #![feature(control_flow_enum)]
+#![feature(generic_nonzero)]
 #![feature(if_let_guard)]
 #![feature(is_sorted)]
 #![feature(iter_intersperse)]

compiler/rustc_interface/src/lib.rs

@@ -1,5 +1,6 @@
 #![feature(decl_macro)]
 #![feature(error_iter)]
+#![feature(generic_nonzero)]
 #![feature(lazy_cell)]
 #![feature(let_chains)]
 #![feature(thread_spawn_unchecked)]

compiler/rustc_interface/src/tests.rs

@@ -20,7 +20,7 @@ use rustc_span::{FileName, SourceFileHashAlgorithm};
 use rustc_target::spec::{CodeModel, LinkerFlavorCli, MergeFunctions, PanicStrategy, RelocModel};
 use rustc_target::spec::{RelroLevel, SanitizerSet, SplitDebuginfo, StackProtector, TlsModel};
 use std::collections::{BTreeMap, BTreeSet};
-use std::num::NonZeroUsize;
+use std::num::NonZero;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
 
@@ -827,7 +827,7 @@ fn test_unstable_options_tracking_hash() {
  tracked!(tls_model, Some(TlsModel::GeneralDynamic));
  tracked!(translate_remapped_path_to_local_path, false);
  tracked!(trap_unreachable, Some(false));
- tracked!(treat_err_as_bug, NonZeroUsize::new(1));
+ tracked!(treat_err_as_bug, NonZero::new(1));
  tracked!(tune_cpu, Some(String::from("abc")));
  tracked!(uninit_const_chunk_threshold, 123);
  tracked!(unleash_the_miri_inside_of_you, true);

compiler/rustc_interface/src/util.rs

@@ -107,7 +107,7 @@ pub(crate) fn run_in_thread_pool_with_globals<F: FnOnce() -> R + Send, R: Send>(
  use rustc_query_impl::QueryCtxt;
  use rustc_query_system::query::{deadlock, QueryContext};
 
- let registry = sync::Registry::new(std::num::NonZeroUsize::new(threads).unwrap());
+ let registry = sync::Registry::new(std::num::NonZero::new(threads).unwrap());
 
  if !sync::is_dyn_thread_safe() {
  return run_in_thread_with_globals(edition, || {

compiler/rustc_lint/src/lib.rs

@@ -31,6 +31,7 @@
 #![feature(array_windows)]
 #![feature(box_patterns)]
 #![feature(control_flow_enum)]
+#![feature(generic_nonzero)]
 #![feature(if_let_guard)]
 #![feature(iter_order_by)]
 #![feature(let_chains)]

compiler/rustc_lint/src/lints.rs

@@ -1,7 +1,6 @@
 #![allow(rustc::diagnostic_outside_of_impl)]
 #![allow(rustc::untranslatable_diagnostic)]
-
-use std::num::NonZeroU32;
+use std::num::NonZero;
 
 use crate::errors::RequestedLevel;
 use crate::fluent_generated as fluent;
@@ -402,7 +401,7 @@ pub struct BuiltinIncompleteFeaturesHelp;
 #[derive(Subdiagnostic)]
 #[note(lint_note)]
 pub struct BuiltinFeatureIssueNote {
- pub n: NonZeroU32,
+ pub n: NonZero<u32>,
 }
 
 pub struct BuiltinUnpermittedTypeInit<'a> {

compiler/rustc_metadata/src/lib.rs

@@ -5,6 +5,7 @@
 #![feature(decl_macro)]
 #![feature(extract_if)]
 #![feature(coroutines)]
+#![feature(generic_nonzero)]
 #![feature(iter_from_coroutine)]
 #![feature(let_chains)]
 #![feature(if_let_guard)]

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -327,7 +327,7 @@ impl<'a, 'tcx> DecodeContext<'a, 'tcx> {
  }
 
  #[inline]
- fn read_lazy_offset_then<T>(&mut self, f: impl Fn(NonZeroUsize) -> T) -> T {
+ fn read_lazy_offset_then<T>(&mut self, f: impl Fn(NonZero<usize>) -> T) -> T {
  let distance = self.read_usize();
  let position = match self.lazy_state {
  LazyState::NoNode => bug!("read_lazy_with_meta: outside of a metadata node"),
@@ -338,7 +338,7 @@ impl<'a, 'tcx> DecodeContext<'a, 'tcx> {
  }
  LazyState::Previous(last_pos) => last_pos.get() + distance,
  };
- let position = NonZeroUsize::new(position).unwrap();
+ let position = NonZero::new(position).unwrap();
  self.lazy_state = LazyState::Previous(position);
  f(position)
  }
@@ -685,15 +685,15 @@ impl MetadataBlob {
  }
 
  pub(crate) fn get_rustc_version(&self) -> String {
- LazyValue::<String>::from_position(NonZeroUsize::new(METADATA_HEADER.len() + 8).unwrap())
+ LazyValue::<String>::from_position(NonZero::new(METADATA_HEADER.len() + 8).unwrap())
  .decode(self)
  }
 
- fn root_pos(&self) -> NonZeroUsize {
+ fn root_pos(&self) -> NonZero<usize> {
  let offset = METADATA_HEADER.len();
  let pos_bytes = self.blob()[offset..][..8].try_into().unwrap();
  let pos = u64::from_le_bytes(pos_bytes);
- NonZeroUsize::new(pos as usize).unwrap()
+ NonZero::new(pos as usize).unwrap()
  }
 
  pub(crate) fn get_header(&self) -> CrateHeader {