Update tests.

reitermarkus · reitermarkus · commit 502f995ffe55 · 2024-01-21T17:43:37.000+01:00
diff --git a/tests/mir-opt/instsimplify/combine_transmutes.adt_transmutes.InstSimplify.diff b/tests/mir-opt/instsimplify/combine_transmutes.adt_transmutes.InstSimplify.diff
@@ -4,7 +4,7 @@
   fn adt_transmutes() -> () {
       let mut _0: ();
       let _1: u8;
-      let mut _2: std::option::Option<std::num::NonZeroU8>;
+      let mut _2: std::option::Option<std::num::NonZero<u8>>;
       let mut _4: std::num::Wrapping<i16>;
       let mut _6: std::num::Wrapping<i16>;
       let mut _8: Union32;
@@ -37,7 +37,7 @@
       bb0: {
           StorageLive(_1);
           StorageLive(_2);
-          _2 = Option::<NonZeroU8>::Some(const _);
+          _2 = Option::<NonZero<u8>>::Some(const _);
           _1 = move _2 as u8 (Transmute);
           StorageDead(_2);
           StorageLive(_3);
diff --git a/tests/ui/layout/zero-sized-array-enum-niche.stderr b/tests/ui/layout/zero-sized-array-enum-niche.stderr
@@ -232,7 +232,7 @@ error: layout_of(MultipleAlignments) = Layout {
 LL | enum MultipleAlignments {
    | ^^^^^^^^^^^^^^^^^^^^^^^
 
-error: layout_of(Result<[u32; 0], Packed<NonZeroU16>>) = Layout {
+error: layout_of(Result<[u32; 0], Packed<NonZero<u16>>>) = Layout {
            size: Size(4 bytes),
            align: AbiAndPrefAlign {
                abi: Align(4 bytes),
diff --git a/tests/ui/lint/clashing-extern-fn.rs b/tests/ui/lint/clashing-extern-fn.rs
@@ -436,7 +436,7 @@ mod hidden_niche {
 
             fn hidden_niche_unsafe_cell() -> Option<UnsafeCell<NonZeroUsize>>;
             //~^ WARN redeclared with a different signature
-            //~| WARN block uses type `Option<UnsafeCell<NonZeroUsize>>`, which is not FFI-safe
+            //~| WARN block uses type `Option<UnsafeCell<NonZero<usize>>>`, which is not FFI-safe
         }
     }
 }
diff --git a/tests/ui/lint/clashing-extern-fn.stderr b/tests/ui/lint/clashing-extern-fn.stderr
@@ -8,7 +8,7 @@ LL |             fn hidden_niche_transparent_no_niche() -> Option<TransparentNoN
    = note: enum has no representation hint
    = note: `#[warn(improper_ctypes)]` on by default
 
-warning: `extern` block uses type `Option<UnsafeCell<NonZeroUsize>>`, which is not FFI-safe
+warning: `extern` block uses type `Option<UnsafeCell<NonZero<usize>>>`, which is not FFI-safe
   --> $DIR/clashing-extern-fn.rs:437:46
    |
 LL |             fn hidden_niche_unsafe_cell() -> Option<UnsafeCell<NonZeroUsize>>;
@@ -163,7 +163,7 @@ LL |             fn non_zero_usize() -> core::num::NonZeroUsize;
 LL |             fn non_zero_usize() -> usize;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
    |
-   = note: expected `unsafe extern "C" fn() -> NonZeroUsize`
+   = note: expected `unsafe extern "C" fn() -> NonZero<usize>`
               found `unsafe extern "C" fn() -> usize`
 
 warning: `non_null_ptr` redeclared with a different signature
@@ -224,7 +224,7 @@ LL |             fn hidden_niche_unsafe_cell() -> Option<UnsafeCell<NonZeroUsize
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration
    |
    = note: expected `unsafe extern "C" fn() -> usize`
-              found `unsafe extern "C" fn() -> Option<UnsafeCell<NonZeroUsize>>`
+              found `unsafe extern "C" fn() -> Option<UnsafeCell<NonZero<usize>>>`
 
 warning: 19 warnings emitted
 
diff --git a/tests/ui/lint/invalid_value.stderr b/tests/ui/lint/invalid_value.stderr
@@ -316,7 +316,7 @@ LL |         let _val: NonNull<i32> = mem::uninitialized();
    = note: `std::ptr::NonNull<i32>` must be non-null
    = note: raw pointers must be initialized
 
-error: the type `(NonZeroU32, i32)` does not permit zero-initialization
+error: the type `(NonZero<u32>, i32)` does not permit zero-initialization
   --> $DIR/invalid_value.rs:95:39
    |
 LL |         let _val: (NonZeroU32, i32) = mem::zeroed();
@@ -325,9 +325,9 @@ LL |         let _val: (NonZeroU32, i32) = mem::zeroed();
    |                                       this code causes undefined behavior when executed
    |                                       help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
    |
-   = note: `std::num::NonZeroU32` must be non-null
+   = note: `std::num::NonZero<u32>` must be non-null
 
-error: the type `(NonZeroU32, i32)` does not permit being left uninitialized
+error: the type `(NonZero<u32>, i32)` does not permit being left uninitialized
   --> $DIR/invalid_value.rs:96:39
    |
 LL |         let _val: (NonZeroU32, i32) = mem::uninitialized();
@@ -336,7 +336,7 @@ LL |         let _val: (NonZeroU32, i32) = mem::uninitialized();
    |                                       this code causes undefined behavior when executed
    |                                       help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
    |
-   = note: `std::num::NonZeroU32` must be non-null
+   = note: `std::num::NonZero<u32>` must be non-null
    = note: integers must be initialized
 
 error: the type `*const dyn Send` does not permit zero-initialization
@@ -417,7 +417,7 @@ LL |         let _val: OneFruitNonZero = mem::zeroed();
    |                                     help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
    |
    = note: `OneFruitNonZero` must be non-null
-note: because `std::num::NonZeroU32` must be non-null (in this field of the only potentially inhabited enum variant)
+note: because `std::num::NonZero<u32>` must be non-null (in this field of the only potentially inhabited enum variant)
   --> $DIR/invalid_value.rs:39:12
    |
 LL |     Banana(NonZeroU32),
@@ -433,7 +433,7 @@ LL |         let _val: OneFruitNonZero = mem::uninitialized();
    |                                     help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
    |
    = note: `OneFruitNonZero` must be non-null
-note: because `std::num::NonZeroU32` must be non-null (in this field of the only potentially inhabited enum variant)
+note: because `std::num::NonZero<u32>` must be non-null (in this field of the only potentially inhabited enum variant)
   --> $DIR/invalid_value.rs:39:12
    |
 LL |     Banana(NonZeroU32),
@@ -603,7 +603,7 @@ LL |         let _val: &'static [i32] = mem::transmute((0usize, 0usize));
    |
    = note: references must be non-null
 
-error: the type `NonZeroU32` does not permit zero-initialization
+error: the type `NonZero<u32>` does not permit zero-initialization
   --> $DIR/invalid_value.rs:154:32
    |
 LL |         let _val: NonZeroU32 = mem::transmute(0);
@@ -612,7 +612,7 @@ LL |         let _val: NonZeroU32 = mem::transmute(0);
    |                                this code causes undefined behavior when executed
    |                                help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
    |
-   = note: `std::num::NonZeroU32` must be non-null
+   = note: `std::num::NonZero<u32>` must be non-null
 
 error: the type `NonNull<i32>` does not permit zero-initialization
   --> $DIR/invalid_value.rs:157:34
diff --git a/tests/ui/lint/lint-ctypes-enum.stderr b/tests/ui/lint/lint-ctypes-enum.stderr
@@ -61,7 +61,7 @@ LL |    fn nonzero_i128(x: Option<num::NonZeroI128>);
    |
    = note: 128-bit integers don't currently have a known stable ABI
 
-error: `extern` block uses type `Option<TransparentUnion<NonZeroU8>>`, which is not FFI-safe
+error: `extern` block uses type `Option<TransparentUnion<NonZero<u8>>>`, which is not FFI-safe
   --> $DIR/lint-ctypes-enum.rs:86:28
    |
 LL |    fn transparent_union(x: Option<TransparentUnion<num::NonZeroU8>>);
@@ -70,7 +70,7 @@ LL |    fn transparent_union(x: Option<TransparentUnion<num::NonZeroU8>>);
    = help: consider adding a `#[repr(C)]`, `#[repr(transparent)]`, or integer `#[repr(...)]` attribute to this enum
    = note: enum has no representation hint
 
-error: `extern` block uses type `Option<Rust<NonZeroU8>>`, which is not FFI-safe
+error: `extern` block uses type `Option<Rust<NonZero<u8>>>`, which is not FFI-safe
   --> $DIR/lint-ctypes-enum.rs:88:20
    |
 LL |    fn repr_rust(x: Option<Rust<num::NonZeroU8>>);
@@ -79,7 +79,7 @@ LL |    fn repr_rust(x: Option<Rust<num::NonZeroU8>>);
    = help: consider adding a `#[repr(C)]`, `#[repr(transparent)]`, or integer `#[repr(...)]` attribute to this enum
    = note: enum has no representation hint
 
-error: `extern` block uses type `Result<(), NonZeroI32>`, which is not FFI-safe
+error: `extern` block uses type `Result<(), NonZero<i32>>`, which is not FFI-safe
   --> $DIR/lint-ctypes-enum.rs:89:20
    |
 LL |    fn no_result(x: Result<(), num::NonZeroI32>);
diff --git a/tests/ui/mismatched_types/non_zero_assigned_something.stderr b/tests/ui/mismatched_types/non_zero_assigned_something.stderr
@@ -2,10 +2,12 @@ error[E0308]: mismatched types
   --> $DIR/non_zero_assigned_something.rs:2:35
    |
 LL |     let _: std::num::NonZeroU64 = 1;
-   |            --------------------   ^ expected `NonZeroU64`, found integer
+   |            --------------------   ^ expected `NonZero<u64>`, found integer
    |            |
    |            expected due to this
    |
+   = note: expected struct `NonZero<u64>`
+                found type `{integer}`
 help: consider calling `NonZeroU64::new`
    |
 LL |     let _: std::num::NonZeroU64 = NonZeroU64::new(1).unwrap();
@@ -15,11 +17,11 @@ error[E0308]: mismatched types
   --> $DIR/non_zero_assigned_something.rs:6:43
    |
 LL |     let _: Option<std::num::NonZeroU64> = 1;
-   |            ----------------------------   ^ expected `Option<NonZeroU64>`, found integer
+   |            ----------------------------   ^ expected `Option<NonZero<u64>>`, found integer
    |            |
    |            expected due to this
    |
-   = note: expected enum `Option<NonZeroU64>`
+   = note: expected enum `Option<NonZero<u64>>`
               found type `{integer}`
 help: consider calling `NonZeroU64::new`
    |
diff --git a/tests/ui/numbers-arithmetic/not-suggest-float-literal.stderr b/tests/ui/numbers-arithmetic/not-suggest-float-literal.stderr
@@ -124,7 +124,7 @@ LL |     x / 100.0
    = help: the trait `Div<{float}>` is not implemented for `u8`
    = help: the following other types implement trait `Div<Rhs>`:
              <u8 as Div>
-             <u8 as Div<NonZeroU8>>
+             <u8 as Div<NonZero<u8>>>
              <u8 as Div<&u8>>
              <&'a u8 as Div<u8>>
              <&u8 as Div<&u8>>
diff --git a/tests/ui/print_type_sizes/niche-filling.stdout b/tests/ui/print_type_sizes/niche-filling.stdout
@@ -14,17 +14,17 @@ print-type-size         field `.pre`: 1 bytes
 print-type-size         field `.post`: 2 bytes
 print-type-size         field `.val`: 4 bytes
 print-type-size     variant `None`: 0 bytes
-print-type-size type: `MyOption<Union1<std::num::NonZeroU32>>`: 8 bytes, alignment: 4 bytes
+print-type-size type: `MyOption<Union1<std::num::NonZero<u32>>>`: 8 bytes, alignment: 4 bytes
 print-type-size     discriminant: 4 bytes
 print-type-size     variant `Some`: 4 bytes
 print-type-size         field `.0`: 4 bytes
 print-type-size     variant `None`: 0 bytes
-print-type-size type: `MyOption<Union2<std::num::NonZeroU32, std::num::NonZeroU32>>`: 8 bytes, alignment: 4 bytes
+print-type-size type: `MyOption<Union2<std::num::NonZero<u32>, std::num::NonZero<u32>>>`: 8 bytes, alignment: 4 bytes
 print-type-size     discriminant: 4 bytes
 print-type-size     variant `Some`: 4 bytes
 print-type-size         field `.0`: 4 bytes
 print-type-size     variant `None`: 0 bytes
-print-type-size type: `MyOption<Union2<std::num::NonZeroU32, u32>>`: 8 bytes, alignment: 4 bytes
+print-type-size type: `MyOption<Union2<std::num::NonZero<u32>, u32>>`: 8 bytes, alignment: 4 bytes
 print-type-size     discriminant: 4 bytes
 print-type-size     variant `Some`: 4 bytes
 print-type-size         field `.0`: 4 bytes
@@ -53,22 +53,22 @@ print-type-size type: `MyOption<char>`: 4 bytes, alignment: 4 bytes
 print-type-size     variant `Some`: 4 bytes
 print-type-size         field `.0`: 4 bytes
 print-type-size     variant `None`: 0 bytes
-print-type-size type: `MyOption<std::num::NonZeroU32>`: 4 bytes, alignment: 4 bytes
+print-type-size type: `MyOption<std::num::NonZero<u32>>`: 4 bytes, alignment: 4 bytes
 print-type-size     variant `Some`: 4 bytes
 print-type-size         field `.0`: 4 bytes
 print-type-size     variant `None`: 0 bytes
-print-type-size type: `Union1<std::num::NonZeroU32>`: 4 bytes, alignment: 4 bytes
+print-type-size type: `Union1<std::num::NonZero<u32>>`: 4 bytes, alignment: 4 bytes
 print-type-size     variant `Union1`: 4 bytes
 print-type-size         field `.a`: 4 bytes
-print-type-size type: `Union2<std::num::NonZeroU32, std::num::NonZeroU32>`: 4 bytes, alignment: 4 bytes
+print-type-size type: `Union2<std::num::NonZero<u32>, std::num::NonZero<u32>>`: 4 bytes, alignment: 4 bytes
 print-type-size     variant `Union2`: 4 bytes
 print-type-size         field `.a`: 4 bytes
 print-type-size         field `.b`: 4 bytes, offset: 0 bytes, alignment: 4 bytes
-print-type-size type: `Union2<std::num::NonZeroU32, u32>`: 4 bytes, alignment: 4 bytes
+print-type-size type: `Union2<std::num::NonZero<u32>, u32>`: 4 bytes, alignment: 4 bytes
 print-type-size     variant `Union2`: 4 bytes
 print-type-size         field `.a`: 4 bytes
 print-type-size         field `.b`: 4 bytes, offset: 0 bytes, alignment: 4 bytes
-print-type-size type: `std::num::NonZeroU32`: 4 bytes, alignment: 4 bytes
+print-type-size type: `std::num::NonZero<u32>`: 4 bytes, alignment: 4 bytes
 print-type-size     field `.0`: 4 bytes
 print-type-size type: `Enum4<(), (), (), MyOption<u8>>`: 2 bytes, alignment: 1 bytes
 print-type-size     variant `Four`: 2 bytes
diff --git a/tests/ui/traits/issue-77982.stderr b/tests/ui/traits/issue-77982.stderr
@@ -45,7 +45,7 @@ LL |     let ips: Vec<_> = (0..100_000).map(|_| u32::from(0u32.into())).collect(
    |
    = note: multiple `impl`s satisfying `u32: From<_>` found in the `core` crate:
            - impl From<Ipv4Addr> for u32;
-           - impl From<NonZeroU32> for u32;
+           - impl From<NonZero<u32>> for u32;
            - impl From<bool> for u32;
            - impl From<char> for u32;
            - impl From<u16> for u32;
diff --git a/tests/ui/try-trait/bad-interconversion.stderr b/tests/ui/try-trait/bad-interconversion.stderr
@@ -11,7 +11,7 @@ LL |     Ok(Err(123_i32)?)
    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
    = help: the following other types implement trait `From<T>`:
              <u8 as From<bool>>
-             <u8 as From<NonZeroU8>>
+             <u8 as From<NonZero<u8>>>
    = note: required for `Result<u64, u8>` to implement `FromResidual<Result<Infallible, i32>>`
 
 error[E0277]: the `?` operator can only be used on `Result`s, not `Option`s, in a function that returns `Result`

Original file line number	Diff line number	Diff line change
`@@ -436,7 +436,7 @@ mod hidden_niche {`
`436`	`436`
`437`	`437`	`fn hidden_niche_unsafe_cell() -> Option<UnsafeCell<NonZeroUsize>>;`
`438`	`438`	`//~^ WARN redeclared with a different signature`
`439`		- //~\| WARN block uses type `Option<UnsafeCell<NonZeroUsize>>`, which is not FFI-safe
	`439`	+ //~\| WARN block uses type `Option<UnsafeCell<NonZero<usize>>>`, which is not FFI-safe
`440`	`440`	`}`
`441`	`441`	`}`
`442`	`442`	`}`
Original file line number	Diff line number	Diff line change
`@@ -316,7 +316,7 @@ LL \| let _val: NonNull<i32> = mem::uninitialized();`
`316`	`316`	= note: `std::ptr::NonNull<i32>` must be non-null
`317`	`317`	`= note: raw pointers must be initialized`
`318`	`318`
`319`		-error: the type `(NonZeroU32, i32)` does not permit zero-initialization
	`319`	+error: the type `(NonZero<u32>, i32)` does not permit zero-initialization
`320`	`320`	`--> $DIR/invalid_value.rs:95:39`
`321`	`321`	`\|`
`322`	`322`	`LL \| let _val: (NonZeroU32, i32) = mem::zeroed();`
`@@ -325,9 +325,9 @@ LL \| let _val: (NonZeroU32, i32) = mem::zeroed();`
`325`	`325`	`\| this code causes undefined behavior when executed`
`326`	`326`	\| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
`327`	`327`	`\|`
`328`		- = note: `std::num::NonZeroU32` must be non-null
	`328`	+ = note: `std::num::NonZero<u32>` must be non-null
`329`	`329`
`330`		-error: the type `(NonZeroU32, i32)` does not permit being left uninitialized
	`330`	+error: the type `(NonZero<u32>, i32)` does not permit being left uninitialized
`331`	`331`	`--> $DIR/invalid_value.rs:96:39`
`332`	`332`	`\|`
`333`	`333`	`LL \| let _val: (NonZeroU32, i32) = mem::uninitialized();`
`@@ -336,7 +336,7 @@ LL \| let _val: (NonZeroU32, i32) = mem::uninitialized();`
`336`	`336`	`\| this code causes undefined behavior when executed`
`337`	`337`	\| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
`338`	`338`	`\|`
`339`		- = note: `std::num::NonZeroU32` must be non-null
	`339`	+ = note: `std::num::NonZero<u32>` must be non-null
`340`	`340`	`= note: integers must be initialized`
`341`	`341`
`342`	`342`	error: the type `*const dyn Send` does not permit zero-initialization
`@@ -417,7 +417,7 @@ LL \| let _val: OneFruitNonZero = mem::zeroed();`
`417`	`417`	\| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
`418`	`418`	`\|`
`419`	`419`	= note: `OneFruitNonZero` must be non-null
`420`		-note: because `std::num::NonZeroU32` must be non-null (in this field of the only potentially inhabited enum variant)
	`420`	+note: because `std::num::NonZero<u32>` must be non-null (in this field of the only potentially inhabited enum variant)
`421`	`421`	`--> $DIR/invalid_value.rs:39:12`
`422`	`422`	`\|`
`423`	`423`	`LL \| Banana(NonZeroU32),`
`@@ -433,7 +433,7 @@ LL \| let _val: OneFruitNonZero = mem::uninitialized();`
`433`	`433`	\| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
`434`	`434`	`\|`
`435`	`435`	= note: `OneFruitNonZero` must be non-null
`436`		-note: because `std::num::NonZeroU32` must be non-null (in this field of the only potentially inhabited enum variant)
	`436`	+note: because `std::num::NonZero<u32>` must be non-null (in this field of the only potentially inhabited enum variant)
`437`	`437`	`--> $DIR/invalid_value.rs:39:12`
`438`	`438`	`\|`
`439`	`439`	`LL \| Banana(NonZeroU32),`
`@@ -603,7 +603,7 @@ LL \| let _val: &'static [i32] = mem::transmute((0usize, 0usize));`
`603`	`603`	`\|`
`604`	`604`	`= note: references must be non-null`
`605`	`605`
`606`		-error: the type `NonZeroU32` does not permit zero-initialization
	`606`	+error: the type `NonZero<u32>` does not permit zero-initialization
`607`	`607`	`--> $DIR/invalid_value.rs:154:32`
`608`	`608`	`\|`
`609`	`609`	`LL \| let _val: NonZeroU32 = mem::transmute(0);`
`@@ -612,7 +612,7 @@ LL \| let _val: NonZeroU32 = mem::transmute(0);`
`612`	`612`	`\| this code causes undefined behavior when executed`
`613`	`613`	\| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done
`614`	`614`	`\|`
`615`		- = note: `std::num::NonZeroU32` must be non-null
	`615`	+ = note: `std::num::NonZero<u32>` must be non-null
`616`	`616`
`617`	`617`	error: the type `NonNull<i32>` does not permit zero-initialization
`618`	`618`	`--> $DIR/invalid_value.rs:157:34`
Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,7 @@ LL \| fn nonzero_i128(x: Option<num::NonZeroI128>);`
`61`	`61`	`\|`
`62`	`62`	`= note: 128-bit integers don't currently have a known stable ABI`
`63`	`63`
`64`		-error: `extern` block uses type `Option<TransparentUnion<NonZeroU8>>`, which is not FFI-safe
	`64`	+error: `extern` block uses type `Option<TransparentUnion<NonZero<u8>>>`, which is not FFI-safe
`65`	`65`	`--> $DIR/lint-ctypes-enum.rs:86:28`
`66`	`66`	`\|`
`67`	`67`	`LL \| fn transparent_union(x: Option<TransparentUnion<num::NonZeroU8>>);`
`@@ -70,7 +70,7 @@ LL \| fn transparent_union(x: Option<TransparentUnion<num::NonZeroU8>>);`
`70`	`70`	= help: consider adding a `#[repr(C)]`, `#[repr(transparent)]`, or integer `#[repr(...)]` attribute to this enum
`71`	`71`	`= note: enum has no representation hint`
`72`	`72`
`73`		-error: `extern` block uses type `Option<Rust<NonZeroU8>>`, which is not FFI-safe
	`73`	+error: `extern` block uses type `Option<Rust<NonZero<u8>>>`, which is not FFI-safe
`74`	`74`	`--> $DIR/lint-ctypes-enum.rs:88:20`
`75`	`75`	`\|`
`76`	`76`	`LL \| fn repr_rust(x: Option<Rust<num::NonZeroU8>>);`
`@@ -79,7 +79,7 @@ LL \| fn repr_rust(x: Option<Rust<num::NonZeroU8>>);`
`79`	`79`	= help: consider adding a `#[repr(C)]`, `#[repr(transparent)]`, or integer `#[repr(...)]` attribute to this enum
`80`	`80`	`= note: enum has no representation hint`
`81`	`81`
`82`		-error: `extern` block uses type `Result<(), NonZeroI32>`, which is not FFI-safe
	`82`	+error: `extern` block uses type `Result<(), NonZero<i32>>`, which is not FFI-safe
`83`	`83`	`--> $DIR/lint-ctypes-enum.rs:89:20`
`84`	`84`	`\|`
`85`	`85`	`LL \| fn no_result(x: Result<(), num::NonZeroI32>);`
Original file line number	Diff line number	Diff line change
`@@ -2,10 +2,12 @@ error[E0308]: mismatched types`
`2`	`2`	`--> $DIR/non_zero_assigned_something.rs:2:35`
`3`	`3`	`\|`
`4`	`4`	`LL \| let _: std::num::NonZeroU64 = 1;`
`5`		- \| -------------------- ^ expected `NonZeroU64`, found integer
	`5`	+ \| -------------------- ^ expected `NonZero<u64>`, found integer
`6`	`6`	`\| \|`
`7`	`7`	`\| expected due to this`
`8`	`8`	`\|`
	`9`	+ = note: expected struct `NonZero<u64>`
	`10`	+ found type `{integer}`
`9`	`11`	help: consider calling `NonZeroU64::new`
`10`	`12`	`\|`
`11`	`13`	`LL \| let _: std::num::NonZeroU64 = NonZeroU64::new(1).unwrap();`
`@@ -15,11 +17,11 @@ error[E0308]: mismatched types`
`15`	`17`	`--> $DIR/non_zero_assigned_something.rs:6:43`
`16`	`18`	`\|`
`17`	`19`	`LL \| let _: Option<std::num::NonZeroU64> = 1;`
`18`		- \| ---------------------------- ^ expected `Option<NonZeroU64>`, found integer
	`20`	+ \| ---------------------------- ^ expected `Option<NonZero<u64>>`, found integer
`19`	`21`	`\| \|`
`20`	`22`	`\| expected due to this`
`21`	`23`	`\|`
`22`		- = note: expected enum `Option<NonZeroU64>`
	`24`	+ = note: expected enum `Option<NonZero<u64>>`
`23`	`25`	found type `{integer}`
`24`	`26`	help: consider calling `NonZeroU64::new`
`25`	`27`	`\|`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ LL \| let ips: Vec<_> = (0..100_000).map(\|_\| u32::from(0u32.into())).collect(`
`45`	`45`	`\|`
`46`	`46`	= note: multiple `impl`s satisfying `u32: From<_>` found in the `core` crate:
`47`	`47`	`- impl From<Ipv4Addr> for u32;`
`48`		`- - impl From<NonZeroU32> for u32;`
	`48`	`+ - impl From<NonZero<u32>> for u32;`
`49`	`49`	`- impl From<bool> for u32;`
`50`	`50`	`- impl From<char> for u32;`
`51`	`51`	`- impl From<u16> for u32;`