mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fix 32bit tests

Browse Source
This commit is contained in:
Philipp Krones 2023-09-07 22:31:30 +02:00
parent 25e8639676
commit 184c9712b2
No known key found for this signature in database
GPG Key ID: 1CA0DF2AF59D68A5
6 changed files with 332 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
tests/ui/cast_size.32bit.stderr
View File

@ -6,6 +6,7 @@ LL | 1isize as i8;
|
= help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
= note: `-D clippy::cast-possible-truncation` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::cast_possible_truncation)]`
help: ... or use `try_from` and handle the error accordingly
|
LL | i8::try_from(1isize);
@ -18,6 +19,7 @@ LL | x0 as f64;
| ^^^^^^^^^
|
= note: `-D clippy::cast-precision-loss` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::cast_precision_loss)]`
error: casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
--> $DIR/cast_size.rs:19:5
@ -92,6 +94,7 @@ LL | 1usize as i32;
| ^^^^^^^^^^^^^
|
= note: `-D clippy::cast-possible-wrap` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::cast_possible_wrap)]`
error: casting `i64` to `isize` may truncate the value on targets with 32-bit wide pointers
--> $DIR/cast_size.rs:26:5

48
tests/ui/fn_to_numeric_cast.32bit.stderr
View File

@ -1,141 +1,143 @@
error: casting function pointer `foo` to `i8`, which truncates the value
--> $DIR/fn_to_numeric_cast.rs:11:13
--> $DIR/fn_to_numeric_cast.rs:10:13
|
LL | let _ = foo as i8;
| ^^^^^^^^^ help: try: `foo as usize`
|
= note: `-D clippy::fn-to-numeric-cast-with-truncation` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::fn_to_numeric_cast_with_truncation)]`
error: casting function pointer `foo` to `i16`, which truncates the value
--> $DIR/fn_to_numeric_cast.rs:12:13
--> $DIR/fn_to_numeric_cast.rs:11:13
|
LL | let _ = foo as i16;
| ^^^^^^^^^^ help: try: `foo as usize`
error: casting function pointer `foo` to `i32`
--> $DIR/fn_to_numeric_cast.rs:13:13
--> $DIR/fn_to_numeric_cast.rs:12:13
|
LL | let _ = foo as i32;
| ^^^^^^^^^^ help: try: `foo as usize`
|
= note: `-D clippy::fn-to-numeric-cast` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::fn_to_numeric_cast)]`
error: casting function pointer `foo` to `i64`
--> $DIR/fn_to_numeric_cast.rs:14:13
--> $DIR/fn_to_numeric_cast.rs:13:13
|
LL | let _ = foo as i64;
| ^^^^^^^^^^ help: try: `foo as usize`
error: casting function pointer `foo` to `i128`
--> $DIR/fn_to_numeric_cast.rs:15:13
--> $DIR/fn_to_numeric_cast.rs:14:13
|
LL | let _ = foo as i128;
| ^^^^^^^^^^^ help: try: `foo as usize`
error: casting function pointer `foo` to `isize`
--> $DIR/fn_to_numeric_cast.rs:16:13
--> $DIR/fn_to_numeric_cast.rs:15:13
|
LL | let _ = foo as isize;
| ^^^^^^^^^^^^ help: try: `foo as usize`
error: casting function pointer `foo` to `u8`, which truncates the value
--> $DIR/fn_to_numeric_cast.rs:18:13
--> $DIR/fn_to_numeric_cast.rs:17:13
|
LL | let _ = foo as u8;
| ^^^^^^^^^ help: try: `foo as usize`
error: casting function pointer `foo` to `u16`, which truncates the value
--> $DIR/fn_to_numeric_cast.rs:19:13
--> $DIR/fn_to_numeric_cast.rs:18:13
|
LL | let _ = foo as u16;
| ^^^^^^^^^^ help: try: `foo as usize`
error: casting function pointer `foo` to `u32`
--> $DIR/fn_to_numeric_cast.rs:20:13
--> $DIR/fn_to_numeric_cast.rs:19:13
|
LL | let _ = foo as u32;
| ^^^^^^^^^^ help: try: `foo as usize`
error: casting function pointer `foo` to `u64`
--> $DIR/fn_to_numeric_cast.rs:21:13
--> $DIR/fn_to_numeric_cast.rs:20:13
|
LL | let _ = foo as u64;
| ^^^^^^^^^^ help: try: `foo as usize`
error: casting function pointer `foo` to `u128`
--> $DIR/fn_to_numeric_cast.rs:22:13
--> $DIR/fn_to_numeric_cast.rs:21:13
|
LL | let _ = foo as u128;
| ^^^^^^^^^^^ help: try: `foo as usize`
error: casting function pointer `abc` to `i8`, which truncates the value
--> $DIR/fn_to_numeric_cast.rs:35:13
--> $DIR/fn_to_numeric_cast.rs:34:13
|
LL | let _ = abc as i8;
| ^^^^^^^^^ help: try: `abc as usize`
error: casting function pointer `abc` to `i16`, which truncates the value
--> $DIR/fn_to_numeric_cast.rs:36:13
--> $DIR/fn_to_numeric_cast.rs:35:13
|
LL | let _ = abc as i16;
| ^^^^^^^^^^ help: try: `abc as usize`
error: casting function pointer `abc` to `i32`
--> $DIR/fn_to_numeric_cast.rs:37:13
--> $DIR/fn_to_numeric_cast.rs:36:13
|
LL | let _ = abc as i32;
| ^^^^^^^^^^ help: try: `abc as usize`
error: casting function pointer `abc` to `i64`
--> $DIR/fn_to_numeric_cast.rs:38:13
--> $DIR/fn_to_numeric_cast.rs:37:13
|
LL | let _ = abc as i64;
| ^^^^^^^^^^ help: try: `abc as usize`
error: casting function pointer `abc` to `i128`
--> $DIR/fn_to_numeric_cast.rs:39:13
--> $DIR/fn_to_numeric_cast.rs:38:13
|
LL | let _ = abc as i128;
| ^^^^^^^^^^^ help: try: `abc as usize`
error: casting function pointer `abc` to `isize`
--> $DIR/fn_to_numeric_cast.rs:40:13
--> $DIR/fn_to_numeric_cast.rs:39:13
|
LL | let _ = abc as isize;
| ^^^^^^^^^^^^ help: try: `abc as usize`
error: casting function pointer `abc` to `u8`, which truncates the value
--> $DIR/fn_to_numeric_cast.rs:42:13
--> $DIR/fn_to_numeric_cast.rs:41:13
|
LL | let _ = abc as u8;
| ^^^^^^^^^ help: try: `abc as usize`
error: casting function pointer `abc` to `u16`, which truncates the value
--> $DIR/fn_to_numeric_cast.rs:43:13
--> $DIR/fn_to_numeric_cast.rs:42:13
|
LL | let _ = abc as u16;
| ^^^^^^^^^^ help: try: `abc as usize`
error: casting function pointer `abc` to `u32`
--> $DIR/fn_to_numeric_cast.rs:44:13
--> $DIR/fn_to_numeric_cast.rs:43:13
|
LL | let _ = abc as u32;
| ^^^^^^^^^^ help: try: `abc as usize`
error: casting function pointer `abc` to `u64`
--> $DIR/fn_to_numeric_cast.rs:45:13
--> $DIR/fn_to_numeric_cast.rs:44:13
|
LL | let _ = abc as u64;
| ^^^^^^^^^^ help: try: `abc as usize`
error: casting function pointer `abc` to `u128`
--> $DIR/fn_to_numeric_cast.rs:46:13
--> $DIR/fn_to_numeric_cast.rs:45:13
|
LL | let _ = abc as u128;
| ^^^^^^^^^^^ help: try: `abc as usize`
error: casting function pointer `f` to `i32`
--> $DIR/fn_to_numeric_cast.rs:53:5
--> $DIR/fn_to_numeric_cast.rs:52:5
|
LL | f as i32
| ^^^^^^^^ help: try: `f as usize`

280
tests/ui/large_enum_variant.32bit.stderr Normal file
View File

@ -0,0 +1,280 @@
error: large size difference between variants
--> $DIR/large_enum_variant.rs:11:1
|
LL | / enum LargeEnum {
LL | | A(i32),
| | ------ the second-largest variant contains at least 4 bytes
LL | | B([i32; 8000]),
| | -------------- the largest variant contains at least 32000 bytes
LL | | }
| |_^ the entire enum is at least 32004 bytes
|
= note: `-D clippy::large-enum-variant` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::large_enum_variant)]`
help: consider boxing the large fields to reduce the total size of the enum
|
LL | B(Box<[i32; 8000]>),
| ~~~~~~~~~~~~~~~~
error: large size difference between variants
--> $DIR/large_enum_variant.rs:35:1
|
LL | / enum LargeEnum2 {
LL | | VariantOk(i32, u32),
| | ------------------- the second-largest variant contains at least 8 bytes
LL | | ContainingLargeEnum(LargeEnum),
| | ------------------------------ the largest variant contains at least 32004 bytes
LL | | }
| |_^ the entire enum is at least 32004 bytes
|
help: consider boxing the large fields to reduce the total size of the enum
|
LL | ContainingLargeEnum(Box<LargeEnum>),
| ~~~~~~~~~~~~~~
error: large size difference between variants
--> $DIR/large_enum_variant.rs:40:1
|
LL | / enum LargeEnum3 {
LL | | ContainingMoreThanOneField(i32, [i32; 8000], [i32; 9500]),
| | --------------------------------------------------------- the largest variant contains at least 70004 bytes
LL | | VoidVariant,
LL | | StructLikeLittle { x: i32, y: i32 },
| | ----------------------------------- the second-largest variant contains at least 8 bytes
LL | | }
| |_^ the entire enum is at least 70008 bytes
|
help: consider boxing the large fields to reduce the total size of the enum
|
LL | ContainingMoreThanOneField(i32, Box<[i32; 8000]>, Box<[i32; 9500]>),
| ~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~
error: large size difference between variants
--> $DIR/large_enum_variant.rs:46:1
|
LL | / enum LargeEnum4 {
LL | | VariantOk(i32, u32),
| | ------------------- the second-largest variant contains at least 8 bytes
LL | | StructLikeLarge { x: [i32; 8000], y: i32 },
| | ------------------------------------------ the largest variant contains at least 32004 bytes
LL | | }
| |_^ the entire enum is at least 32008 bytes
|
help: consider boxing the large fields to reduce the total size of the enum
|
LL | StructLikeLarge { x: Box<[i32; 8000]>, y: i32 },
| ~~~~~~~~~~~~~~~~
error: large size difference between variants
--> $DIR/large_enum_variant.rs:51:1
|
LL | / enum LargeEnum5 {
LL | | VariantOk(i32, u32),
| | ------------------- the second-largest variant contains at least 8 bytes
LL | | StructLikeLarge2 { x: [i32; 8000] },
| | ----------------------------------- the largest variant contains at least 32000 bytes
LL | | }
| |_^ the entire enum is at least 32004 bytes
|
help: consider boxing the large fields to reduce the total size of the enum
|
LL | StructLikeLarge2 { x: Box<[i32; 8000]> },
| ~~~~~~~~~~~~~~~~
error: large size difference between variants
--> $DIR/large_enum_variant.rs:67:1
|
LL | / enum LargeEnum7 {
LL | | A,
LL | | B([u8; 1255]),
| | ------------- the largest variant contains at least 1255 bytes
LL | | C([u8; 200]),
| | ------------ the second-largest variant contains at least 200 bytes
LL | | }
| |_^ the entire enum is at least 1256 bytes
|
help: consider boxing the large fields to reduce the total size of the enum
|
LL | B(Box<[u8; 1255]>),
| ~~~~~~~~~~~~~~~
error: large size difference between variants
--> $DIR/large_enum_variant.rs:73:1
|
LL | / enum LargeEnum8 {
LL | | VariantOk(i32, u32),
| | ------------------- the second-largest variant contains at least 8 bytes
LL | | ContainingMoreThanOneField([i32; 8000], [i32; 2], [i32; 9500], [i32; 30]),
| | ------------------------------------------------------------------------- the largest variant contains at least 70128 bytes
LL | | }
| |_^ the entire enum is at least 70132 bytes
|
help: consider boxing the large fields to reduce the total size of the enum
|
LL | ContainingMoreThanOneField(Box<[i32; 8000]>, [i32; 2], Box<[i32; 9500]>, [i32; 30]),
| ~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~
error: large size difference between variants
--> $DIR/large_enum_variant.rs:78:1
|
LL | / enum LargeEnum9 {
LL | | A(Struct<()>),
| | ------------- the second-largest variant contains at least 4 bytes
LL | | B(Struct2),
| | ---------- the largest variant contains at least 32000 bytes
LL | | }
| |_^ the entire enum is at least 32004 bytes
|
help: consider boxing the large fields to reduce the total size of the enum
|
LL | B(Box<Struct2>),
| ~~~~~~~~~~~~
error: large size difference between variants
--> $DIR/large_enum_variant.rs:83:1
|
LL | / enum LargeEnumOk2<T> {
LL | | A(T),
| | ---- the second-largest variant contains at least 0 bytes
LL | | B(Struct2),
| | ---------- the largest variant contains at least 32000 bytes
LL | | }
| |_^ the entire enum is at least 32000 bytes
|
help: consider boxing the large fields to reduce the total size of the enum
|
LL | B(Box<Struct2>),
| ~~~~~~~~~~~~
error: large size difference between variants
--> $DIR/large_enum_variant.rs:88:1
|
LL | / enum LargeEnumOk3<T> {
LL | | A(Struct<T>),
| | ------------ the second-largest variant contains at least 4 bytes
LL | | B(Struct2),
| | ---------- the largest variant contains at least 32000 bytes
LL | | }
| |_^ the entire enum is at least 32000 bytes
|
help: consider boxing the large fields to reduce the total size of the enum
|
LL | B(Box<Struct2>),
| ~~~~~~~~~~~~
error: large size difference between variants
--> $DIR/large_enum_variant.rs:103:1
|
LL | / enum CopyableLargeEnum {
LL | | A(bool),
| | ------- the second-largest variant contains at least 1 bytes
LL | | B([u64; 8000]),
| | -------------- the largest variant contains at least 64000 bytes
LL | | }
| |_^ the entire enum is at least 64004 bytes
|
note: boxing a variant would require the type no longer be `Copy`
--> $DIR/large_enum_variant.rs:103:6
|
LL | enum CopyableLargeEnum {
| ^^^^^^^^^^^^^^^^^
help: consider boxing the large fields to reduce the total size of the enum
--> $DIR/large_enum_variant.rs:105:5
|
LL | B([u64; 8000]),
| ^^^^^^^^^^^^^^
error: large size difference between variants
--> $DIR/large_enum_variant.rs:108:1
|
LL | / enum ManuallyCopyLargeEnum {
LL | | A(bool),
| | ------- the second-largest variant contains at least 1 bytes
LL | | B([u64; 8000]),
| | -------------- the largest variant contains at least 64000 bytes
LL | | }
| |_^ the entire enum is at least 64004 bytes
|
note: boxing a variant would require the type no longer be `Copy`
--> $DIR/large_enum_variant.rs:108:6
|
LL | enum ManuallyCopyLargeEnum {
| ^^^^^^^^^^^^^^^^^^^^^
help: consider boxing the large fields to reduce the total size of the enum
--> $DIR/large_enum_variant.rs:110:5
|
LL | B([u64; 8000]),
| ^^^^^^^^^^^^^^
error: large size difference between variants
--> $DIR/large_enum_variant.rs:121:1
|
LL | / enum SomeGenericPossiblyCopyEnum<T> {
LL | | A(bool, std::marker::PhantomData<T>),
| | ------------------------------------ the second-largest variant contains at least 1 bytes
LL | | B([u64; 4000]),
| | -------------- the largest variant contains at least 32000 bytes
LL | | }
| |_^ the entire enum is at least 32004 bytes
|
note: boxing a variant would require the type no longer be `Copy`
--> $DIR/large_enum_variant.rs:121:6
|
LL | enum SomeGenericPossiblyCopyEnum<T> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: consider boxing the large fields to reduce the total size of the enum
--> $DIR/large_enum_variant.rs:123:5
|
LL | B([u64; 4000]),
| ^^^^^^^^^^^^^^
error: large size difference between variants
--> $DIR/large_enum_variant.rs:134:1
|
LL | / enum LargeEnumWithGenerics<T> {
LL | | Small,
| | ----- the second-largest variant carries no data at all
LL | | Large((T, [u8; 512])),
| | --------------------- the largest variant contains at least 512 bytes
LL | | }
| |_^ the entire enum is at least 512 bytes
|
help: consider boxing the large fields to reduce the total size of the enum
|
LL | Large(Box<(T, [u8; 512])>),
| ~~~~~~~~~~~~~~~~~~~
error: large size difference between variants
--> $DIR/large_enum_variant.rs:143:1
|
LL | / enum WithGenerics {
LL | | Large([Foo<u64>; 64]),
| | --------------------- the largest variant contains at least 512 bytes
LL | | Small(u8),
| | --------- the second-largest variant contains at least 1 bytes
LL | | }
| |_^ the entire enum is at least 516 bytes
|
help: consider boxing the large fields to reduce the total size of the enum
|
LL | Large(Box<[Foo<u64>; 64]>),
| ~~~~~~~~~~~~~~~~~~~
error: large size difference between variants
--> $DIR/large_enum_variant.rs:153:1
|
LL | / enum LargeEnumOfConst {
LL | | Ok,
| | -- the second-largest variant carries no data at all
LL | | Error(PossiblyLargeEnumWithConst<256>),
| | -------------------------------------- the largest variant contains at least 514 bytes
LL | | }
| |_^ the entire enum is at least 514 bytes
|
help: consider boxing the large fields to reduce the total size of the enum
|
LL | Error(Box<PossiblyLargeEnumWithConst<256>>),
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
error: aborting due to 16 previous errors

44
tests/ui/large_enum_variant.stderr → tests/ui/large_enum_variant.64bit.stderr
View File

@ -1,5 +1,5 @@
error: large size difference between variants
--> $DIR/large_enum_variant.rs:10:1
--> $DIR/large_enum_variant.rs:11:1
|
LL | / enum LargeEnum {
LL | | A(i32),
@ -17,7 +17,7 @@ LL | B(Box<[i32; 8000]>),
| ~~~~~~~~~~~~~~~~
error: large size difference between variants
--> $DIR/large_enum_variant.rs:34:1
--> $DIR/large_enum_variant.rs:35:1
|
LL | / enum LargeEnum2 {
LL | | VariantOk(i32, u32),
@ -33,7 +33,7 @@ LL | ContainingLargeEnum(Box<LargeEnum>),
| ~~~~~~~~~~~~~~
error: large size difference between variants
--> $DIR/large_enum_variant.rs:39:1
--> $DIR/large_enum_variant.rs:40:1
|
LL | / enum LargeEnum3 {
LL | | ContainingMoreThanOneField(i32, [i32; 8000], [i32; 9500]),
@ -50,7 +50,7 @@ LL | ContainingMoreThanOneField(i32, Box<[i32; 8000]>, Box<[i32; 9500]>),
| ~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~
error: large size difference between variants
--> $DIR/large_enum_variant.rs:45:1
--> $DIR/large_enum_variant.rs:46:1
|
LL | / enum LargeEnum4 {
LL | | VariantOk(i32, u32),
@ -66,7 +66,7 @@ LL | StructLikeLarge { x: Box<[i32; 8000]>, y: i32 },
| ~~~~~~~~~~~~~~~~
error: large size difference between variants
--> $DIR/large_enum_variant.rs:50:1
--> $DIR/large_enum_variant.rs:51:1
|
LL | / enum LargeEnum5 {
LL | | VariantOk(i32, u32),
@ -82,7 +82,7 @@ LL | StructLikeLarge2 { x: Box<[i32; 8000]> },
| ~~~~~~~~~~~~~~~~
error: large size difference between variants
--> $DIR/large_enum_variant.rs:66:1
--> $DIR/large_enum_variant.rs:67:1
|
LL | / enum LargeEnum7 {
LL | | A,
@ -99,7 +99,7 @@ LL | B(Box<[u8; 1255]>),
| ~~~~~~~~~~~~~~~
error: large size difference between variants
--> $DIR/large_enum_variant.rs:72:1
--> $DIR/large_enum_variant.rs:73:1
|
LL | / enum LargeEnum8 {
LL | | VariantOk(i32, u32),
@ -115,7 +115,7 @@ LL | ContainingMoreThanOneField(Box<[i32; 8000]>, [i32; 2], Box<[i32; 9500]>
| ~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~
error: large size difference between variants
--> $DIR/large_enum_variant.rs:77:1
--> $DIR/large_enum_variant.rs:78:1
|
LL | / enum LargeEnum9 {
LL | | A(Struct<()>),
@ -131,7 +131,7 @@ LL | B(Box<Struct2>),
| ~~~~~~~~~~~~
error: large size difference between variants
--> $DIR/large_enum_variant.rs:82:1
--> $DIR/large_enum_variant.rs:83:1
|
LL | / enum LargeEnumOk2<T> {
LL | | A(T),
@ -147,7 +147,7 @@ LL | B(Box<Struct2>),
| ~~~~~~~~~~~~
error: large size difference between variants
--> $DIR/large_enum_variant.rs:87:1
--> $DIR/large_enum_variant.rs:88:1
|
LL | / enum LargeEnumOk3<T> {
LL | | A(Struct<T>),
@ -163,7 +163,7 @@ LL | B(Box<Struct2>),
| ~~~~~~~~~~~~
error: large size difference between variants
--> $DIR/large_enum_variant.rs:102:1
--> $DIR/large_enum_variant.rs:103:1
|
LL | / enum CopyableLargeEnum {
LL | | A(bool),
@ -174,18 +174,18 @@ LL | | }
| |_^ the entire enum is at least 64008 bytes
|
note: boxing a variant would require the type no longer be `Copy`
--> $DIR/large_enum_variant.rs:102:6
--> $DIR/large_enum_variant.rs:103:6
|
LL | enum CopyableLargeEnum {
| ^^^^^^^^^^^^^^^^^
help: consider boxing the large fields to reduce the total size of the enum
--> $DIR/large_enum_variant.rs:104:5
--> $DIR/large_enum_variant.rs:105:5
|
LL | B([u64; 8000]),
| ^^^^^^^^^^^^^^
error: large size difference between variants
--> $DIR/large_enum_variant.rs:107:1
--> $DIR/large_enum_variant.rs:108:1
|
LL | / enum ManuallyCopyLargeEnum {
LL | | A(bool),
@ -196,18 +196,18 @@ LL | | }
| |_^ the entire enum is at least 64008 bytes
|
note: boxing a variant would require the type no longer be `Copy`
--> $DIR/large_enum_variant.rs:107:6
--> $DIR/large_enum_variant.rs:108:6
|
LL | enum ManuallyCopyLargeEnum {
| ^^^^^^^^^^^^^^^^^^^^^
help: consider boxing the large fields to reduce the total size of the enum
--> $DIR/large_enum_variant.rs:109:5
--> $DIR/large_enum_variant.rs:110:5
|
LL | B([u64; 8000]),
| ^^^^^^^^^^^^^^
error: large size difference between variants
--> $DIR/large_enum_variant.rs:120:1
--> $DIR/large_enum_variant.rs:121:1
|
LL | / enum SomeGenericPossiblyCopyEnum<T> {
LL | | A(bool, std::marker::PhantomData<T>),
@ -218,18 +218,18 @@ LL | | }
| |_^ the entire enum is at least 32008 bytes
|
note: boxing a variant would require the type no longer be `Copy`
--> $DIR/large_enum_variant.rs:120:6
--> $DIR/large_enum_variant.rs:121:6
|
LL | enum SomeGenericPossiblyCopyEnum<T> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: consider boxing the large fields to reduce the total size of the enum
--> $DIR/large_enum_variant.rs:122:5
--> $DIR/large_enum_variant.rs:123:5
|
LL | B([u64; 4000]),
| ^^^^^^^^^^^^^^
error: large size difference between variants
--> $DIR/large_enum_variant.rs:133:1
--> $DIR/large_enum_variant.rs:134:1
|
LL | / enum LargeEnumWithGenerics<T> {
LL | | Small,
@ -245,7 +245,7 @@ LL | Large(Box<(T, [u8; 512])>),
| ~~~~~~~~~~~~~~~~~~~
error: large size difference between variants
--> $DIR/large_enum_variant.rs:142:1
--> $DIR/large_enum_variant.rs:143:1
|
LL | / enum WithGenerics {
LL | | Large([Foo<u64>; 64]),
@ -261,7 +261,7 @@ LL | Large(Box<[Foo<u64>; 64]>),
| ~~~~~~~~~~~~~~~~~~~
error: large size difference between variants
--> $DIR/large_enum_variant.rs:152:1
--> $DIR/large_enum_variant.rs:153:1
|
LL | / enum LargeEnumOfConst {
LL | | Ok,

1
tests/ui/large_enum_variant.rs
View File

@ -1,3 +1,4 @@
//@stderr-per-bitwidth
//@aux-build:proc_macros.rs
//@no-rustfix
#![allow(dead_code)]

1
tests/ui/transmute_32bit.stderr
View File

@ -5,6 +5,7 @@ LL | let _: *const usize = std::mem::transmute(6.0f32);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: `-D clippy::wrong-transmute` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::wrong_transmute)]`
error: transmute from a `f32` to a pointer
--> $DIR/transmute_32bit.rs:8:29