Use `NonZero<T>` instead of `NonZeroT`

[sorairolake]

What it does

NonZero<T> stabilized with Rust 1.79.0. This allows NonZeroI32 to be written as NonZero<i32>.

Advantage

• More readable.
• Reduce imports.
• Can specify aliases for primitive integer types (e.g., NonZero<c_int>).

Drawbacks

MSRV is 1.79.0.

Example

let x = NonZeroI32::new(42).unwrap();

Could be written as:

let x = NonZero::<i32>::new(42).unwrap();

[TennyZhuang]

@rustbot claim

[y21]

I'm struggling to see the advantage here.

NonZero being generic is definitely cool and it's nice that you can use c_int, but I don't see how this helps users when they've already got a NonZeroI32 and are only interested in that.
I don't think there's any readability difference or that it reduces imports when you specifically need NonZeroI32 and that only in a file; you either import NonZero or you import NonZeroI32.

Can you provide a use case for where this lint would have helped?

[sorairolake]

@y21 I think it's useful when you need multiple types.

use core::num::{NonZeroI32, NonZeroU32, NonZeroU8};

let x = NonZeroU8::new(42).unwrap();
let x = NonZeroI32::new(42).unwrap();
let x = NonZeroU32::new(42).unwrap();

Could be written as:

use core::num::NonZero;

let x = NonZero::<u8>::new(42).unwrap();
let x = NonZero::<i32>::new(42).unwrap();
let x = NonZero::<u32>::new(42).unwrap();

[leonardo-m]

use core::num::NonZero;

let x = NonZero::::new(42).unwrap();
let x = NonZero::::new(42).unwrap();
let x = NonZero::::new(42).unwrap();

An alternative version is:

#![allow(unused_variables)]
#![feature(const_option)]

use core::num::NonZero;

fn main() {
    let x1 = const { NonZero::new(42_u8).unwrap() };
    let x2 = const { NonZero::new(42_i32).unwrap() };
    let x = const { NonZero::new(42_u32).unwrap() };
}

(By the way, sometimes I'd like a unwrap-less constructor for NonZero).