rust/tests/ui/large_enum_variant.32bit.stderr

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