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