src/tools/clippy/tests/ui/large_enum_variant.rs

   1 // aux-build:proc_macros.rs
   2
   3 #![allow(dead_code)]
   4 #![allow(unused_variables)]
   5 #![warn(clippy::large_enum_variant)]
   6
   7 extern crate proc_macros;
   8 use proc_macros::external;
   9
  10 enum LargeEnum {
  11     A(i32),
  12     B([i32; 8000]),
  13 }
  14
  15 enum GenericEnumOk<T> {
  16     A(i32),
  17     B([T; 8000]),
  18 }
  19
  20 enum GenericEnum2<T> {
  21     A(i32),
  22     B([i32; 8000]),
  23     C(T, [i32; 8000]),
  24 }
  25
  26 trait SomeTrait {
  27     type Item;
  28 }
  29
  30 enum LargeEnumGeneric<A: SomeTrait> {
  31     Var(A::Item),
  32 }
  33
  34 enum LargeEnum2 {
  35     VariantOk(i32, u32),
  36     ContainingLargeEnum(LargeEnum),
  37 }
  38
  39 enum LargeEnum3 {
  40     ContainingMoreThanOneField(i32, [i32; 8000], [i32; 9500]),
  41     VoidVariant,
  42     StructLikeLittle { x: i32, y: i32 },
  43 }
  44
  45 enum LargeEnum4 {
  46     VariantOk(i32, u32),
  47     StructLikeLarge { x: [i32; 8000], y: i32 },
  48 }
  49
  50 enum LargeEnum5 {
  51     VariantOk(i32, u32),
  52     StructLikeLarge2 { x: [i32; 8000] },
  53 }
  54
  55 enum LargeEnumOk {
  56     LargeA([i32; 8000]),
  57     LargeB([i32; 8001]),
  58 }
  59
  60 enum LargeEnum6 {
  61     A,
  62     B([u8; 255]),
  63     C([u8; 200]),
  64 }
  65
  66 enum LargeEnum7 {
  67     A,
  68     B([u8; 1255]),
  69     C([u8; 200]),
  70 }
  71
  72 enum LargeEnum8 {
  73     VariantOk(i32, u32),
  74     ContainingMoreThanOneField([i32; 8000], [i32; 2], [i32; 9500], [i32; 30]),
  75 }
  76
  77 enum LargeEnum9 {
  78     A(Struct<()>),
  79     B(Struct2),
  80 }
  81
  82 enum LargeEnumOk2<T> {
  83     A(T),
  84     B(Struct2),
  85 }
  86
  87 enum LargeEnumOk3<T> {
  88     A(Struct<T>),
  89     B(Struct2),
  90 }
  91
  92 struct Struct<T> {
  93     a: i32,
  94     t: T,
  95 }
  96
  97 struct Struct2 {
  98     a: [i32; 8000],
  99 }
 100
 101 #[derive(Copy, Clone)]
 102 enum CopyableLargeEnum {
 103     A(bool),
 104     B([u64; 8000]),
 105 }
 106
 107 enum ManuallyCopyLargeEnum {
 108     A(bool),
 109     B([u64; 8000]),
 110 }
 111
 112 impl Clone for ManuallyCopyLargeEnum {
 113     fn clone(&self) -> Self {
 114         *self
 115     }
 116 }
 117
 118 impl Copy for ManuallyCopyLargeEnum {}
 119
 120 enum SomeGenericPossiblyCopyEnum<T> {
 121     A(bool, std::marker::PhantomData<T>),
 122     B([u64; 4000]),
 123 }
 124
 125 impl<T: Copy> Clone for SomeGenericPossiblyCopyEnum<T> {
 126     fn clone(&self) -> Self {
 127         *self
 128     }
 129 }
 130
 131 impl<T: Copy> Copy for SomeGenericPossiblyCopyEnum<T> {}
 132
 133 enum LargeEnumWithGenerics<T> {
 134     Small,
 135     Large((T, [u8; 512])),
 136 }
 137
 138 struct Foo<T> {
 139     foo: T,
 140 }
 141
 142 enum WithGenerics {
 143     Large([Foo<u64>; 64]),
 144     Small(u8),
 145 }
 146
 147 enum PossiblyLargeEnumWithConst<const U: usize> {
 148     SmallBuffer([u8; 4]),
 149     MightyBuffer([u16; U]),
 150 }
 151
 152 enum LargeEnumOfConst {
 153     Ok,
 154     Error(PossiblyLargeEnumWithConst<256>),
 155 }
 156
 157 fn main() {
 158     external!(
 159         enum LargeEnumInMacro {
 160             A(i32),
 161             B([i32; 8000]),
 162         }
 163     );
 164 }