diff --git a/compiler/rustc_abi/src/layout.rs b/compiler/rustc_abi/src/layout.rs
index a95ef4c460f45..c57be5d110641 100644
--- a/compiler/rustc_abi/src/layout.rs
+++ b/compiler/rustc_abi/src/layout.rs
@@ -2,6 +2,7 @@ use std::borrow::{Borrow, Cow};
use std::cmp;
use std::fmt::{self, Write};
use std::iter;
+use std::num::NonZero;
use std::ops::Bound;
use std::ops::Deref;
@@ -10,8 +11,8 @@ use tracing::debug;
use crate::{
Abi, AbiAndPrefAlign, Align, FieldsShape, IndexSlice, IndexVec, Integer, LayoutS, Niche,
- NonZeroUsize, Primitive, ReprOptions, Scalar, Size, StructKind, TagEncoding, TargetDataLayout,
- Variants, WrappingRange,
+ Primitive, ReprOptions, Scalar, Size, StructKind, TagEncoding, TargetDataLayout, Variants,
+ WrappingRange,
};
// A variant is absent if it's uninhabited and only has ZST fields.
@@ -327,7 +328,7 @@ pub trait LayoutCalculator {
Some(LayoutS {
variants: Variants::Single { index: VariantIdx::new(0) },
- fields: FieldsShape::Union(NonZeroUsize::new(only_variant.len())?),
+ fields: FieldsShape::Union(NonZero::new(only_variant.len())?),
abi,
largest_niche: None,
align,
diff --git a/compiler/rustc_abi/src/lib.rs b/compiler/rustc_abi/src/lib.rs
index 6a2943da4a3fb..a6fe49f434889 100644
--- a/compiler/rustc_abi/src/lib.rs
+++ b/compiler/rustc_abi/src/lib.rs
@@ -4,7 +4,7 @@
#![cfg_attr(feature = "nightly", feature(rustdoc_internals))]
use std::fmt;
-use std::num::{NonZeroUsize, ParseIntError};
+use std::num::{NonZero, ParseIntError};
use std::ops::{Add, AddAssign, Mul, RangeInclusive, Sub};
use std::str::FromStr;
@@ -1147,7 +1147,7 @@ pub enum FieldsShape<FieldIdx: Idx> {
Primitive,
/// All fields start at no offset. The `usize` is the field count.
- Union(NonZeroUsize),
+ Union(NonZero<usize>),
/// Array/vector-like placement, with all fields of identical types.
Array { stride: Size, count: u64 },
diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index fa378e19f71ab..554b6b8f0f7f4 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -2164,7 +2164,7 @@ pub enum TyKind {
MacCall(P<MacCall>),
/// Placeholder for a `va_list`.
CVarArgs,
- /// Pattern types like `pattern_type!(u32 is 1..=)`, which is the same as `NonZeroU32`,
+ /// Pattern types like `pattern_type!(u32 is 1..=)`, which is the same as `NonZero<u32>`,
/// just as part of the type system.
Pat(P<Ty>, P<Pat>),
/// Sometimes we need a dummy value when no error has occurred.
diff --git a/compiler/stable_mir/src/abi.rs b/compiler/stable_mir/src/abi.rs
index 92bc2e34561ae..e1c14fe0b380b 100644
--- a/compiler/stable_mir/src/abi.rs
+++ b/compiler/stable_mir/src/abi.rs
@@ -6,7 +6,7 @@ use crate::ty::{Align, IndexedVal, Ty, VariantIdx};
use crate::Error;
use crate::Opaque;
use std::fmt::{self, Debug};
-use std::num::NonZeroUsize;
+use std::num::NonZero;
use std::ops::RangeInclusive;
/// A function ABI definition.
@@ -133,7 +133,7 @@ pub enum FieldsShape {
Primitive,
/// All fields start at no offset. The `usize` is the field count.
- Union(NonZeroUsize),
+ Union(NonZero<usize>),
/// Array/vector-like placement, with all fields of identical types.
Array { stride: Size, count: u64 },
diff --git a/library/core/src/iter/adapters/step_by.rs b/library/core/src/iter/adapters/step_by.rs
index a5cf069d407c0..abdf2f415fe55 100644
--- a/library/core/src/iter/adapters/step_by.rs
+++ b/library/core/src/iter/adapters/step_by.rs
@@ -1,7 +1,7 @@
use crate::{
intrinsics,
iter::{from_fn, TrustedLen, TrustedRandomAccess},
- num::NonZeroUsize,
+ num::NonZero,
ops::{Range, Try},
};
@@ -42,10 +42,10 @@ impl<I> StepBy<I> {
/// The `step` that was originally passed to `Iterator::step_by(step)`,
/// aka `self.step_minus_one + 1`.
#[inline]
- fn original_step(&self) -> NonZeroUsize {
+ fn original_step(&self) -> NonZero<usize> {
// SAFETY: By type invariant, `step_minus_one` cannot be `MAX`, which
// means the addition cannot overflow and the result cannot be zero.
- unsafe { NonZeroUsize::new_unchecked(intrinsics::unchecked_add(self.step_minus_one, 1)) }
+ unsafe { NonZero::new_unchecked(intrinsics::unchecked_add(self.step_minus_one, 1)) }
}
}
@@ -231,12 +231,12 @@ unsafe impl<I: Iterator> StepByImpl<I> for StepBy<I> {
#[inline]
default fn spec_size_hint(&self) -> (usize, Option<usize>) {
#[inline]
- fn first_size(step: NonZeroUsize) -> impl Fn(usize) -> usize {
+ fn first_size(step: NonZero<usize>) -> impl Fn(usize) -> usize {
move |n| if n == 0 { 0 } else { 1 + (n - 1) / step }
}
#[inline]
- fn other_size(step: NonZeroUsize) -> impl Fn(usize) -> usize {
+ fn other_size(step: NonZero<usize>) -> impl Fn(usize) -> usize {
move |n| n / step
}
diff --git a/src/tools/build-manifest/src/main.rs b/src/tools/build-manifest/src/main.rs
index f3972346bb5be..bed76263b4516 100644
--- a/src/tools/build-manifest/src/main.rs
+++ b/src/tools/build-manifest/src/main.rs
@@ -236,7 +236,7 @@ fn main() {
let num_threads = if let Some(num) = env::var_os("BUILD_MANIFEST_NUM_THREADS") {
num.to_str().unwrap().parse().expect("invalid number for BUILD_MANIFEST_NUM_THREADS")
} else {
- std::thread::available_parallelism().map_or(1, std::num::NonZeroUsize::get)
+ std::thread::available_parallelism().map_or(1, std::num::NonZero::get)
};
rayon::ThreadPoolBuilder::new()
.num_threads(num_threads)
diff --git a/src/tools/clippy/clippy_lints/src/transmute/eager_transmute.rs b/src/tools/clippy/clippy_lints/src/transmute/eager_transmute.rs
index c44f5150dd1a9..1dfc9f7091e8c 100644
--- a/src/tools/clippy/clippy_lints/src/transmute/eager_transmute.rs
+++ b/src/tools/clippy/clippy_lints/src/transmute/eager_transmute.rs
@@ -87,7 +87,7 @@ pub(super) fn check<'tcx>(
&& is_normalizable(cx, cx.param_env, from_ty)
&& is_normalizable(cx, cx.param_env, to_ty)
// we only want to lint if the target type has a niche that is larger than the one of the source type
- // e.g. `u8` to `NonZeroU8` should lint, but `NonZeroU8` to `u8` should not
+ // e.g. `u8` to `NonZero<u8>` should lint, but `NonZero<u8>` to `u8` should not
&& let Ok(from_layout) = cx.tcx.layout_of(cx.param_env.and(from_ty))
&& let Ok(to_layout) = cx.tcx.layout_of(cx.param_env.and(to_ty))
&& match (from_layout.largest_niche, to_layout.largest_niche) {
diff --git a/src/tools/clippy/lintcheck/src/config.rs b/src/tools/clippy/lintcheck/src/config.rs
index e678d40795ee8..3f712f453fa0a 100644
--- a/src/tools/clippy/lintcheck/src/config.rs
+++ b/src/tools/clippy/lintcheck/src/config.rs
@@ -1,5 +1,5 @@
use clap::Parser;
-use std::num::NonZeroUsize;
+use std::num::NonZero;
use std::path::PathBuf;
#[derive(Clone, Debug, Parser)]
@@ -61,7 +61,7 @@ impl LintcheckConfig {
config.max_jobs = if config.fix || config.recursive {
1
} else {
- std::thread::available_parallelism().map_or(1, NonZeroUsize::get)
+ std::thread::available_parallelism().map_or(1, NonZero::get)
};
};
diff --git a/src/tools/clippy/tests/ui/arithmetic_side_effects.rs b/src/tools/clippy/tests/ui/arithmetic_side_effects.rs
index 66d71f337f2f6..33a91e8bbbe53 100644
--- a/src/tools/clippy/tests/ui/arithmetic_side_effects.rs
+++ b/src/tools/clippy/tests/ui/arithmetic_side_effects.rs
@@ -15,7 +15,7 @@
extern crate proc_macro_derive;
-use core::num::{NonZeroUsize, Saturating, Wrapping};
+use core::num::{NonZero, Saturating, Wrapping};
const ONE: i32 = 1;
const ZERO: i32 = 0;
@@ -494,15 +494,15 @@ pub fn issue_11262() {
}
pub fn issue_11392() {
- fn example_div(unsigned: usize, nonzero_unsigned: NonZeroUsize) -> usize {
+ fn example_div(unsigned: usize, nonzero_unsigned: NonZero<usize>) -> usize {
unsigned / nonzero_unsigned
}
- fn example_rem(unsigned: usize, nonzero_unsigned: NonZeroUsize) -> usize {
+ fn example_rem(unsigned: usize, nonzero_unsigned: NonZero<usize>) -> usize {
unsigned % nonzero_unsigned
}
- let (unsigned, nonzero_unsigned) = (0, NonZeroUsize::new(1).unwrap());
+ let (unsigned, nonzero_unsigned) = (0, NonZero::new(1).unwrap());
example_div(unsigned, nonzero_unsigned);
example_rem(unsigned, nonzero_unsigned);
}
diff --git a/src/tools/clippy/tests/ui/eager_transmute.fixed b/src/tools/clippy/tests/ui/eager_transmute.fixed
index c29e7dd9ab3ea..ba4342462dca0 100644
--- a/src/tools/clippy/tests/ui/eager_transmute.fixed
+++ b/src/tools/clippy/tests/ui/eager_transmute.fixed
@@ -2,7 +2,7 @@
#![warn(clippy::eager_transmute)]
#![allow(clippy::transmute_int_to_non_zero, clippy::missing_transmute_annotations)]
-use std::num::NonZeroU8;
+use std::num::NonZero;
#[repr(u8)]
enum Opcode {
@@ -85,21 +85,21 @@ macro_rules! impls {
}
impls!(NonMaxU8, NonZeroNonMaxU8);
-fn niche_tests(v1: u8, v2: NonZeroU8, v3: NonZeroNonMaxU8) {
- // u8 -> NonZeroU8, do lint
- let _: Option<NonZeroU8> = (v1 > 0).then(|| unsafe { std::mem::transmute(v1) });
+fn niche_tests(v1: u8, v2: NonZero<u8>, v3: NonZeroNonMaxU8) {
+ // u8 -> NonZero<u8>, do lint
+ let _: Option<NonZero<u8>> = (v1 > 0).then(|| unsafe { std::mem::transmute(v1) });
- // NonZeroU8 -> u8, don't lint, target type has no niche and therefore a higher validity range
- let _: Option<u8> = (v2 > NonZeroU8::new(1).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
+ // NonZero<u8> -> u8, don't lint, target type has no niche and therefore a higher validity range
+ let _: Option<u8> = (v2 > NonZero::new(1u8).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
- // NonZeroU8 -> NonMaxU8, do lint, different niche
- let _: Option<NonMaxU8> = (v2 < NonZeroU8::new(255).unwrap()).then(|| unsafe { std::mem::transmute(v2) });
+ // NonZero<u8> -> NonMaxU8, do lint, different niche
+ let _: Option<NonMaxU8> = (v2 < NonZero::new(255u8).unwrap()).then(|| unsafe { std::mem::transmute(v2) });
// NonZeroNonMaxU8 -> NonMaxU8, don't lint, target type has more validity
let _: Option<NonMaxU8> = (v3 < 255).then_some(unsafe { std::mem::transmute(v2) });
- // NonZeroU8 -> NonZeroNonMaxU8, do lint, target type has less validity
- let _: Option<NonZeroNonMaxU8> = (v2 < NonZeroU8::new(255).unwrap()).then(|| unsafe { std::mem::transmute(v2) });
+ // NonZero<u8> -> NonZeroNonMaxU8, do lint, target type has less validity
+ let _: Option<NonZeroNonMaxU8> = (v2 < NonZero::new(255u8).unwrap()).then(|| unsafe { std::mem::transmute(v2) });
}
fn main() {}
diff --git a/src/tools/clippy/tests/ui/eager_transmute.rs b/src/tools/clippy/tests/ui/eager_transmute.rs
index 491a9485c9327..9750e87ce5741 100644
--- a/src/tools/clippy/tests/ui/eager_transmute.rs
+++ b/src/tools/clippy/tests/ui/eager_transmute.rs
@@ -2,7 +2,7 @@
#![warn(clippy::eager_transmute)]
#![allow(clippy::transmute_int_to_non_zero, clippy::missing_transmute_annotations)]
-use std::num::NonZeroU8;
+use std::num::NonZero;
#[repr(u8)]
enum Opcode {
@@ -85,21 +85,21 @@ macro_rules! impls {
}
impls!(NonMaxU8, NonZeroNonMaxU8);
-fn niche_tests(v1: u8, v2: NonZeroU8, v3: NonZeroNonMaxU8) {
- // u8 -> NonZeroU8, do lint
- let _: Option<NonZeroU8> = (v1 > 0).then_some(unsafe { std::mem::transmute(v1) });
+fn niche_tests(v1: u8, v2: NonZero<u8>, v3: NonZeroNonMaxU8) {
+ // u8 -> NonZero<u8>, do lint
+ let _: Option<NonZero<u8>> = (v1 > 0).then_some(unsafe { std::mem::transmute(v1) });
- // NonZeroU8 -> u8, don't lint, target type has no niche and therefore a higher validity range
- let _: Option<u8> = (v2 > NonZeroU8::new(1).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
+ // NonZero<u8> -> u8, don't lint, target type has no niche and therefore a higher validity range
+ let _: Option<u8> = (v2 > NonZero::new(1u8).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
- // NonZeroU8 -> NonMaxU8, do lint, different niche
- let _: Option<NonMaxU8> = (v2 < NonZeroU8::new(255).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
+ // NonZero<u8> -> NonMaxU8, do lint, different niche
+ let _: Option<NonMaxU8> = (v2 < NonZero::new(255u8).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
// NonZeroNonMaxU8 -> NonMaxU8, don't lint, target type has more validity
let _: Option<NonMaxU8> = (v3 < 255).then_some(unsafe { std::mem::transmute(v2) });
- // NonZeroU8 -> NonZeroNonMaxU8, do lint, target type has less validity
- let _: Option<NonZeroNonMaxU8> = (v2 < NonZeroU8::new(255).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
+ // NonZero<u8> -> NonZeroNonMaxU8, do lint, target type has less validity
+ let _: Option<NonZeroNonMaxU8> = (v2 < NonZero::new(255u8).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
}
fn main() {}
diff --git a/src/tools/clippy/tests/ui/eager_transmute.stderr b/src/tools/clippy/tests/ui/eager_transmute.stderr
index b9a4321d99efe..5cf7bd49a929e 100644
--- a/src/tools/clippy/tests/ui/eager_transmute.stderr
+++ b/src/tools/clippy/tests/ui/eager_transmute.stderr
@@ -155,36 +155,36 @@ LL | (op < 4).then(|| std::mem::transmute::<_, Opcode>(op));
| ~~~~ ++
error: this transmute is always evaluated eagerly, even if the condition is false
- --> tests/ui/eager_transmute.rs:90:60
+ --> tests/ui/eager_transmute.rs:90:62
|
-LL | let _: Option<NonZeroU8> = (v1 > 0).then_some(unsafe { std::mem::transmute(v1) });
- | ^^^^^^^^^^^^^^^^^^^^^^^
+LL | let _: Option<NonZero<u8>> = (v1 > 0).then_some(unsafe { std::mem::transmute(v1) });
+ | ^^^^^^^^^^^^^^^^^^^^^^^
|
help: consider using `bool::then` to only transmute if the condition holds
|
-LL | let _: Option<NonZeroU8> = (v1 > 0).then(|| unsafe { std::mem::transmute(v1) });
- | ~~~~ ++
+LL | let _: Option<NonZero<u8>> = (v1 > 0).then(|| unsafe { std::mem::transmute(v1) });
+ | ~~~~ ++
error: this transmute is always evaluated eagerly, even if the condition is false
--> tests/ui/eager_transmute.rs:96:86
|
-LL | let _: Option<NonMaxU8> = (v2 < NonZeroU8::new(255).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
+LL | let _: Option<NonMaxU8> = (v2 < NonZero::new(255u8).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
| ^^^^^^^^^^^^^^^^^^^^^^^
|
help: consider using `bool::then` to only transmute if the condition holds
|
-LL | let _: Option<NonMaxU8> = (v2 < NonZeroU8::new(255).unwrap()).then(|| unsafe { std::mem::transmute(v2) });
+LL | let _: Option<NonMaxU8> = (v2 < NonZero::new(255u8).unwrap()).then(|| unsafe { std::mem::transmute(v2) });
| ~~~~ ++
error: this transmute is always evaluated eagerly, even if the condition is false
--> tests/ui/eager_transmute.rs:102:93
|
-LL | let _: Option<NonZeroNonMaxU8> = (v2 < NonZeroU8::new(255).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
+LL | let _: Option<NonZeroNonMaxU8> = (v2 < NonZero::new(255u8).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
| ^^^^^^^^^^^^^^^^^^^^^^^
|
help: consider using `bool::then` to only transmute if the condition holds
|
-LL | let _: Option<NonZeroNonMaxU8> = (v2 < NonZeroU8::new(255).unwrap()).then(|| unsafe { std::mem::transmute(v2) });
+LL | let _: Option<NonZeroNonMaxU8> = (v2 < NonZero::new(255u8).unwrap()).then(|| unsafe { std::mem::transmute(v2) });
| ~~~~ ++
error: aborting due to 17 previous errors
diff --git a/src/tools/clippy/tests/ui/transmute_int_to_non_zero.stderr b/src/tools/clippy/tests/ui/transmute_int_to_non_zero.stderr
index bb0b0d0ff4f06..b1a46a0da5301 100644
--- a/src/tools/clippy/tests/ui/transmute_int_to_non_zero.stderr
+++ b/src/tools/clippy/tests/ui/transmute_int_to_non_zero.stderr
@@ -1,65 +1,65 @@
-error: transmute from a `u8` to a `NonZeroU8`
- --> tests/ui/transmute_int_to_non_zero.rs:19:33
+error: transmute from a `u8` to a `std::num::NonZero<u8>`
+ --> tests/ui/transmute_int_to_non_zero.rs:19:35
|
-LL | let _: NonZeroU8 = unsafe { std::mem::transmute(int_u8) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZeroU8::new_unchecked(int_u8)`
+LL | let _: NonZero<u8> = unsafe { std::mem::transmute(int_u8) };
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZero::new_unchecked(int_u8)`
|
= note: `-D clippy::transmute-int-to-non-zero` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::transmute_int_to_non_zero)]`
-error: transmute from a `u16` to a `NonZeroU16`
- --> tests/ui/transmute_int_to_non_zero.rs:22:34
+error: transmute from a `u16` to a `std::num::NonZero<u16>`
+ --> tests/ui/transmute_int_to_non_zero.rs:22:36
|
-LL | let _: NonZeroU16 = unsafe { std::mem::transmute(int_u16) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZeroU16::new_unchecked(int_u16)`
+LL | let _: NonZero<u16> = unsafe { std::mem::transmute(int_u16) };
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZero::new_unchecked(int_u16)`
-error: transmute from a `u32` to a `NonZeroU32`
- --> tests/ui/transmute_int_to_non_zero.rs:24:34
+error: transmute from a `u32` to a `std::num::NonZero<u32>`
+ --> tests/ui/transmute_int_to_non_zero.rs:24:36
|
-LL | let _: NonZeroU32 = unsafe { std::mem::transmute(int_u32) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZeroU32::new_unchecked(int_u32)`
+LL | let _: NonZero<u32> = unsafe { std::mem::transmute(int_u32) };
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZero::new_unchecked(int_u32)`
-error: transmute from a `u64` to a `NonZeroU64`
- --> tests/ui/transmute_int_to_non_zero.rs:26:34
+error: transmute from a `u64` to a `std::num::NonZero<u64>`
+ --> tests/ui/transmute_int_to_non_zero.rs:26:36
|
-LL | let _: NonZeroU64 = unsafe { std::mem::transmute(int_u64) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZeroU64::new_unchecked(int_u64)`
+LL | let _: NonZero<u64> = unsafe { std::mem::transmute(int_u64) };
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZero::new_unchecked(int_u64)`
-error: transmute from a `u128` to a `NonZeroU128`
- --> tests/ui/transmute_int_to_non_zero.rs:28:35
+error: transmute from a `u128` to a `std::num::NonZero<u128>`
+ --> tests/ui/transmute_int_to_non_zero.rs:28:37
|
-LL | let _: NonZeroU128 = unsafe { std::mem::transmute(int_u128) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZeroU128::new_unchecked(int_u128)`
+LL | let _: NonZero<u128> = unsafe { std::mem::transmute(int_u128) };
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZero::new_unchecked(int_u128)`
-error: transmute from a `i8` to a `NonZeroI8`
- --> tests/ui/transmute_int_to_non_zero.rs:31:33
+error: transmute from a `i8` to a `std::num::NonZero<i8>`
+ --> tests/ui/transmute_int_to_non_zero.rs:31:35
|
-LL | let _: NonZeroI8 = unsafe { std::mem::transmute(int_i8) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZeroI8::new_unchecked(int_i8)`
+LL | let _: NonZero<i8> = unsafe { std::mem::transmute(int_i8) };
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZero::new_unchecked(int_i8)`
-error: transmute from a `i16` to a `NonZeroI16`
- --> tests/ui/transmute_int_to_non_zero.rs:33:34
+error: transmute from a `i16` to a `std::num::NonZero<i16>`
+ --> tests/ui/transmute_int_to_non_zero.rs:33:36
|
-LL | let _: NonZeroI16 = unsafe { std::mem::transmute(int_i16) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZeroI16::new_unchecked(int_i16)`
+LL | let _: NonZero<i16> = unsafe { std::mem::transmute(int_i16) };
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZero::new_unchecked(int_i16)`
-error: transmute from a `i32` to a `NonZeroI32`
- --> tests/ui/transmute_int_to_non_zero.rs:35:34
+error: transmute from a `i32` to a `std::num::NonZero<i32>`
+ --> tests/ui/transmute_int_to_non_zero.rs:35:36
|
-LL | let _: NonZeroI32 = unsafe { std::mem::transmute(int_i32) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZeroI32::new_unchecked(int_i32)`
+LL | let _: NonZero<i32> = unsafe { std::mem::transmute(int_i32) };
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZero::new_unchecked(int_i32)`
-error: transmute from a `i64` to a `NonZeroI64`
- --> tests/ui/transmute_int_to_non_zero.rs:37:34
+error: transmute from a `i64` to a `std::num::NonZero<i64>`
+ --> tests/ui/transmute_int_to_non_zero.rs:37:36
|
-LL | let _: NonZeroI64 = unsafe { std::mem::transmute(int_i64) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZeroI64::new_unchecked(int_i64)`
+LL | let _: NonZero<i64> = unsafe { std::mem::transmute(int_i64) };
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZero::new_unchecked(int_i64)`
-error: transmute from a `i128` to a `NonZeroI128`
- --> tests/ui/transmute_int_to_non_zero.rs:39:35
+error: transmute from a `i128` to a `std::num::NonZero<i128>`
+ --> tests/ui/transmute_int_to_non_zero.rs:39:37
|
-LL | let _: NonZeroI128 = unsafe { std::mem::transmute(int_i128) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZeroI128::new_unchecked(int_i128)`
+LL | let _: NonZero<i128> = unsafe { std::mem::transmute(int_i128) };
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZero::new_unchecked(int_i128)`
error: aborting due to 10 previous errors
diff --git a/src/tools/miri/tests/fail/enum-set-discriminant-niche-variant-wrong.rs b/src/tools/miri/tests/fail/enum-set-discriminant-niche-variant-wrong.rs
index 428f371ca51c7..eca6d908b448b 100644
--- a/src/tools/miri/tests/fail/enum-set-discriminant-niche-variant-wrong.rs
+++ b/src/tools/miri/tests/fail/enum-set-discriminant-niche-variant-wrong.rs
@@ -2,7 +2,7 @@
#![feature(custom_mir)]
use std::intrinsics::mir::*;
-use std::num::NonZeroI32;
+use std::num::NonZero;
// We define our own option type so that we can control the variant indices.
#[allow(unused)]
@@ -13,7 +13,7 @@ enum Option<T> {
use Option::*;
#[custom_mir(dialect = "runtime", phase = "optimized")]
-fn set_discriminant(ptr: &mut Option<NonZeroI32>) {
+fn set_discriminant(ptr: &mut Option<NonZero<i32>>) {
mir! {
{
// We set the discriminant to `Some`, which is a NOP since this is the niched variant.
diff --git a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_repr_C.rs b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_repr_C.rs
index 2cf4e04477778..c5900489b4c64 100644
--- a/src/tools/miri/tests/fail/function_pointers/abi_mismatch_repr_C.rs
+++ b/src/tools/miri/tests/fail/function_pointers/abi_mismatch_repr_C.rs
@@ -1,7 +1,7 @@
-use std::num::*;
+use std::num::NonZero;
#[repr(C)]
-struct S1(NonZeroI32);
+struct S1(NonZero<i32>);
#[repr(C)]
struct S2(i32);
@@ -11,6 +11,6 @@ fn callee(_s: S2) {}
fn main() {
let fnptr: fn(S2) = callee;
let fnptr: fn(S1) = unsafe { std::mem::transmute(fnptr) };
- fnptr(S1(NonZeroI32::new(1).unwrap()));
+ fnptr(S1(NonZero::new(1).unwrap()));
//~^ ERROR: calling a function with argument of type S2 passing data of type S1
}
diff --git a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_callee_ret.rs b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_callee_ret.rs
index 7cdc15c609495..9fabdd8e86ba4 100644
--- a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_callee_ret.rs
+++ b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_callee_ret.rs
@@ -2,15 +2,15 @@
#![feature(core_intrinsics, custom_mir)]
use std::intrinsics::mir::*;
-use std::num::NonZeroU32;
+use std::num::NonZero;
use std::ptr;
-// This function supposedly returns a NonZeroU32, but actually returns something invalid in a way that
-// never materializes a bad NonZeroU32 value: we take a pointer to the return place and cast the pointer
+// This function supposedly returns a `NonZero<u32>`, but actually returns something invalid in a way that
+// never materializes a bad `NonZero<u32>` value: we take a pointer to the return place and cast the pointer
// type. That way we never get an "invalid value constructed" error inside the function, it can
// only possibly be detected when the return value is passed to the caller.
#[custom_mir(dialect = "runtime", phase = "optimized")]
-fn f() -> NonZeroU32 {
+fn f() -> NonZero<u32> {
mir! {
{
let tmp = ptr::addr_of_mut!(RET);
@@ -22,7 +22,7 @@ fn f() -> NonZeroU32 {
}
fn main() {
- let f: fn() -> u32 = unsafe { std::mem::transmute(f as fn() -> NonZeroU32) };
- // There's a NonZeroU32-to-u32 transmute happening here
+ let f: fn() -> u32 = unsafe { std::mem::transmute(f as fn() -> NonZero<u32>) };
+ // There's a `NonZero<u32>` to `u32` transmute happening here.
f(); //~ERROR: expected something greater or equal to 1
}
diff --git a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_arg.rs b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_arg.rs
index 3a87bb786776e..7ca26bffc14fd 100644
--- a/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_arg.rs
+++ b/src/tools/miri/tests/fail/validity/cast_fn_ptr_invalid_caller_arg.rs
@@ -2,24 +2,24 @@
#![feature(core_intrinsics, custom_mir)]
use std::intrinsics::mir::*;
-use std::num::NonZeroU32;
+use std::num::NonZero;
use std::ptr;
fn f(c: u32) {
println!("{c}");
}
-// Call that function in a bad way, with an invalid NonZeroU32, but without
-// ever materializing this as a NonZeroU32 value outside the call itself.
+// Call that function in a bad way, with an invalid `NonZero<u32>`, but without
+// ever materializing this as a `NonZero<u32>` value outside the call itself.
#[custom_mir(dialect = "runtime", phase = "optimized")]
-fn call(f: fn(NonZeroU32)) {
+fn call(f: fn(NonZero<u32>)) {
mir! {
let _res: ();
{
let c = 0;
let tmp = ptr::addr_of!(c);
- let ptr = tmp as *const NonZeroU32;
- // The call site now is a NonZeroU32-to-u32 transmute.
+ let ptr = tmp as *const NonZero<u32>;
+ // The call site now is a `NonZero<u32>` to `u32` transmute.
Call(_res = f(*ptr), ReturnTo(retblock), UnwindContinue()) //~ERROR: expected something greater or equal to 1
}
retblock = {
@@ -29,6 +29,6 @@ fn call(f: fn(NonZeroU32)) {
}
fn main() {
- let f: fn(NonZeroU32) = unsafe { std::mem::transmute(f as fn(u32)) };
+ let f: fn(NonZero<u32>) = unsafe { std::mem::transmute(f as fn(u32)) };
call(f);
}
diff --git a/src/tools/miri/tests/pass/available-parallelism-miri-num-cpus.rs b/src/tools/miri/tests/pass/available-parallelism-miri-num-cpus.rs
index 137fa51024975..0d96bc2f5e737 100644
--- a/src/tools/miri/tests/pass/available-parallelism-miri-num-cpus.rs
+++ b/src/tools/miri/tests/pass/available-parallelism-miri-num-cpus.rs
@@ -1,8 +1,8 @@
//@compile-flags: -Zmiri-num-cpus=1024
-use std::num::NonZeroUsize;
+use std::num::NonZero;
use std::thread::available_parallelism;
fn main() {
- assert_eq!(available_parallelism().unwrap(), NonZeroUsize::new(1024).unwrap());
+ assert_eq!(available_parallelism().unwrap(), NonZero::new(1024).unwrap());
}
diff --git a/src/tools/miri/tests/pass/function_calls/abi_compat.rs b/src/tools/miri/tests/pass/function_calls/abi_compat.rs
index 14fd2d333d4fb..136660a305aff 100644
--- a/src/tools/miri/tests/pass/function_calls/abi_compat.rs
+++ b/src/tools/miri/tests/pass/function_calls/abi_compat.rs
@@ -70,7 +70,7 @@ fn main() {
test_abi_compat(0usize, 0u64);
test_abi_compat(0isize, 0i64);
}
- test_abi_compat(42u32, num::NonZeroU32::new(1).unwrap());
+ test_abi_compat(42u32, num::NonZero::new(1u32).unwrap());
// - `char` and `u32`.
test_abi_compat(42u32, 'x');
// - Reference/pointer types with the same pointee.
@@ -86,9 +86,9 @@ fn main() {
// - Guaranteed null-pointer-optimizations (RFC 3391).
test_abi_compat(&0u32 as *const u32, Some(&0u32));
test_abi_compat(main as fn(), Some(main as fn()));
- test_abi_compat(0u32, Some(num::NonZeroU32::new(1).unwrap()));
+ test_abi_compat(0u32, Some(num::NonZero::new(1u32).unwrap()));
test_abi_compat(&0u32 as *const u32, Some(Wrapper(&0u32)));
- test_abi_compat(0u32, Some(Wrapper(num::NonZeroU32::new(1).unwrap())));
+ test_abi_compat(0u32, Some(Wrapper(num::NonZero::new(1u32).unwrap())));
// These must work for *any* type, since we guarantee that `repr(transparent)` is ABI-compatible
// with the wrapped field.
@@ -102,7 +102,7 @@ fn main() {
test_abi_newtype::<[u32; 2]>();
test_abi_newtype::<[u32; 32]>();
test_abi_newtype::<Option<i32>>();
- test_abi_newtype::<Option<num::NonZeroU32>>();
+ test_abi_newtype::<Option<num::NonZero<u32>>>();
// Extra test for assumptions made by arbitrary-self-dyn-receivers.
// This is interesting since these types are not `repr(transparent)`. So this is not part of our
diff --git a/src/tools/miri/tests/ui.rs b/src/tools/miri/tests/ui.rs
index efeefbe29fbce..c9d53927b902a 100644
--- a/src/tools/miri/tests/ui.rs
+++ b/src/tools/miri/tests/ui.rs
@@ -1,5 +1,5 @@
use std::ffi::OsString;
-use std::num::NonZeroUsize;
+use std::num::NonZero;
use std::path::{Path, PathBuf};
use std::sync::OnceLock;
use std::{env, process::Command};
@@ -76,7 +76,7 @@ fn miri_config(target: &str, path: &str, mode: Mode, with_dependencies: bool) ->
edition: Some("2021".into()), // keep in sync with `./miri run`
threads: std::env::var("MIRI_TEST_THREADS")
.ok()
- .map(|threads| NonZeroUsize::new(threads.parse().unwrap()).unwrap()),
+ .map(|threads| NonZero::new(threads.parse().unwrap()).unwrap()),
..Config::rustc(path)
};
diff --git a/tests/ui-fulldeps/stable-mir/check_abi.rs b/tests/ui-fulldeps/stable-mir/check_abi.rs
index 74801e007c4dd..359dd4146baf5 100644
--- a/tests/ui-fulldeps/stable-mir/check_abi.rs
+++ b/tests/ui-fulldeps/stable-mir/check_abi.rs
@@ -99,7 +99,7 @@ fn check_result(abi: &ArgAbi) {
assert_matches!(layout.variants, VariantsShape::Multiple { .. })
}
-/// Check the niche information about: `NonZeroU8`
+/// Checks the niche information about `NonZero<u8>`.
fn check_niche(abi: &ArgAbi) {
assert!(abi.ty.kind().is_struct());
assert_matches!(abi.mode, PassMode::Direct { .. });
@@ -150,12 +150,12 @@ fn generate_input(path: &str) -> std::io::Result<()> {
#![feature(c_variadic)]
#![allow(unused_variables)]
- use std::num::NonZeroU8;
+ use std::num::NonZero;
pub fn fn_abi(
ignore: [u8; 0],
primitive: char,
- niche: NonZeroU8,
+ niche: NonZero<u8>,
) -> Result<usize, &'static str> {{
// We only care about the signature.
todo!()
diff --git a/tests/ui/type/pattern_types/range_patterns_usage.rs b/tests/ui/type/pattern_types/range_patterns_usage.rs
index 7fe50423c511b..2a9f736ae61d5 100644
--- a/tests/ui/type/pattern_types/range_patterns_usage.rs
+++ b/tests/ui/type/pattern_types/range_patterns_usage.rs
@@ -8,7 +8,7 @@
use std::pat::pattern_type;
-type X = std::num::NonZeroU32;
+type X = std::num::NonZero<u32>;
type Y = pattern_type!(u32 is 1..);
type Z = Option<pattern_type!(u32 is 1..)>;
struct NonZeroU32New(pattern_type!(u32 is 1..));