fn adt_transmutes() -> () {

let mut _0: ();

let _1: u8;

let mut _4: std::num::Wrapping<i16>;

let mut _6: std::num::Wrapping<i16>;

let mut _8: Union32;

bb0: {

StorageLive(_1);

StorageLive(_2);

_1 = move _2 as u8 (Transmute);

StorageDead(_2);

StorageLive(_3);

LL | enum MultipleAlignments {

| ^^^^^^^^^^^^^^^^^^^^^^^

size: Size(4 bytes),

align: AbiAndPrefAlign {

abi: Align(4 bytes),

fn hidden_niche_unsafe_cell() -> Option<UnsafeCell<NonZeroUsize>>;

//~^ WARN redeclared with a different signature

}

}

= note: enum has no representation hint

= note: `#[warn(improper_ctypes)]` on by default

--> $DIR/clashing-extern-fn.rs:437:46

|

LL | fn hidden_niche_unsafe_cell() -> Option<UnsafeCell<NonZeroUsize>>;

LL | fn non_zero_usize() -> usize;

| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration

|

found `unsafe extern "C" fn() -> usize`

warning: `non_null_ptr` redeclared with a different signature

| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this signature doesn't match the previous declaration

|

= note: expected `unsafe extern "C" fn() -> usize`

warning: 19 warnings emitted

= note: `std::ptr::NonNull<i32>` must be non-null

= note: raw pointers must be initialized

--> $DIR/invalid_value.rs:95:39

|

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

|

--> $DIR/invalid_value.rs:96:39

|

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: integers must be initialized

error: the type `*const dyn Send` does not permit zero-initialization

| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done

|

= note: `OneFruitNonZero` must be non-null

--> $DIR/invalid_value.rs:39:12

|

LL | Banana(NonZeroU32),

| help: use `MaybeUninit<T>` instead, and only call `assume_init` after initialization is done

|

= note: `OneFruitNonZero` must be non-null

--> $DIR/invalid_value.rs:39:12

|

LL | Banana(NonZeroU32),

|

= note: references must be non-null

--> $DIR/invalid_value.rs:154:32

|

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

|

error: the type `NonNull<i32>` does not permit zero-initialization

--> $DIR/invalid_value.rs:157:34

|

= note: 128-bit integers don't currently have a known stable ABI

--> $DIR/lint-ctypes-enum.rs:86:28

|

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

--> $DIR/lint-ctypes-enum.rs:88:20

|

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

--> $DIR/lint-ctypes-enum.rs:89:20

|

LL | fn no_result(x: Result<(), num::NonZeroI32>);

--> $DIR/non_zero_assigned_something.rs:2:35

|

LL | let _: std::num::NonZeroU64 = 1;

| |

| expected due to this

|

help: consider calling `NonZeroU64::new`

|

LL | let _: std::num::NonZeroU64 = NonZeroU64::new(1).unwrap();

--> $DIR/non_zero_assigned_something.rs:6:43

|

LL | let _: Option<std::num::NonZeroU64> = 1;

| |

| expected due to this

|

found type `{integer}`

help: consider calling `NonZeroU64::new`

|

= 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<&u8>>

<&'a u8 as Div<u8>>

<&u8 as Div<&u8>>

print-type-size field `.post`: 2 bytes

print-type-size field `.val`: 4 bytes

print-type-size variant `None`: 0 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 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 discriminant: 4 bytes

print-type-size variant `Some`: 4 bytes

print-type-size field `.0`: 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 variant `Some`: 4 bytes

print-type-size field `.0`: 4 bytes

print-type-size variant `None`: 0 bytes

print-type-size variant `Union1`: 4 bytes

print-type-size field `.a`: 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 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 field `.0`: 4 bytes

print-type-size type: `Enum4<(), (), (), MyOption<u8>>`: 2 bytes, alignment: 1 bytes

print-type-size variant `Four`: 2 bytes

|

= note: multiple `impl`s satisfying `u32: From<_>` found in the `core` crate:

- impl From<Ipv4Addr> for u32;

- impl From<bool> for u32;

- impl From<char> for u32;

- impl From<u16> for u32;

= 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>>

= 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`