]>
Commit | Line | Data |
---|---|---|
49aad941 | 1 | //@aux-build:proc_macros.rs |
f20569fa XL |
2 | |
3 | #![allow(dead_code)] | |
4 | #![allow(unused_variables)] | |
5 | #![warn(clippy::large_enum_variant)] | |
6 | ||
353b0b11 FG |
7 | extern crate proc_macros; |
8 | use proc_macros::external; | |
f20569fa XL |
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 | } | |
c295e0f8 | 38 | |
f20569fa XL |
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 | ||
c295e0f8 XL |
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 | ||
5e7ed085 FG |
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 | ||
923072b8 FG |
101 | #[derive(Copy, Clone)] |
102 | enum CopyableLargeEnum { | |
103 | A(bool), | |
2b03887a | 104 | B([u64; 8000]), |
923072b8 FG |
105 | } |
106 | ||
107 | enum ManuallyCopyLargeEnum { | |
108 | A(bool), | |
2b03887a | 109 | B([u64; 8000]), |
923072b8 FG |
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 | ||
f2b60f7d FG |
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 | ||
f20569fa | 157 | fn main() { |
353b0b11 FG |
158 | external!( |
159 | enum LargeEnumInMacro { | |
160 | A(i32), | |
161 | B([i32; 8000]), | |
162 | } | |
163 | ); | |
f20569fa | 164 | } |