1#[cfg(any(feature = "derive", feature = "full"))]
5use crate::tt::TokenStreamHelper;
6#[cfg(feature = "extra-traits")]
7use alloc::string::ToString;
8#[cfg(any(feature = "derive", feature = "full"))]
9#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
10impl Eq for crate::Abi {}
11#[cfg(any(feature = "derive", feature = "full"))]
12#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
13impl PartialEq for crate::Abi {
14 fn eq(&self, other: &Self) -> bool {
15 self.name == other.name
16 }
17}
18#[cfg(any(feature = "derive", feature = "full"))]
19#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
20impl Eq for crate::AngleBracketedGenericArguments {}
21#[cfg(any(feature = "derive", feature = "full"))]
22#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
23impl PartialEq for crate::AngleBracketedGenericArguments {
24 fn eq(&self, other: &Self) -> bool {
25 self.colon2_token == other.colon2_token && self.args == other.args
26 }
27}
28#[cfg(feature = "full")]
29#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
30impl Eq for crate::Arm {}
31#[cfg(feature = "full")]
32#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
33impl PartialEq for crate::Arm {
34 fn eq(&self, other: &Self) -> bool {
35 self.attrs == other.attrs && self.pat == other.pat && self.body == other.body
36 && self.comma == other.comma
37 }
38}
39#[cfg(any(feature = "derive", feature = "full"))]
40#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
41impl Eq for crate::AssocConst {}
42#[cfg(any(feature = "derive", feature = "full"))]
43#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
44impl PartialEq for crate::AssocConst {
45 fn eq(&self, other: &Self) -> bool {
46 self.ident == other.ident && self.generics == other.generics
47 && self.value == other.value
48 }
49}
50#[cfg(any(feature = "derive", feature = "full"))]
51#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
52impl Eq for crate::AssocType {}
53#[cfg(any(feature = "derive", feature = "full"))]
54#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
55impl PartialEq for crate::AssocType {
56 fn eq(&self, other: &Self) -> bool {
57 self.ident == other.ident && self.generics == other.generics
58 && self.ty == other.ty
59 }
60}
61#[cfg(any(feature = "derive", feature = "full"))]
62#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
63impl Eq for crate::AttrStyle {}
64#[cfg(any(feature = "derive", feature = "full"))]
65#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
66impl PartialEq for crate::AttrStyle {
67 fn eq(&self, other: &Self) -> bool {
68 match (self, other) {
69 (crate::AttrStyle::Outer, crate::AttrStyle::Outer) => true,
70 (crate::AttrStyle::Inner(_), crate::AttrStyle::Inner(_)) => true,
71 _ => false,
72 }
73 }
74}
75#[cfg(any(feature = "derive", feature = "full"))]
76#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
77impl Eq for crate::Attribute {}
78#[cfg(any(feature = "derive", feature = "full"))]
79#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
80impl PartialEq for crate::Attribute {
81 fn eq(&self, other: &Self) -> bool {
82 self.style == other.style && self.meta == other.meta
83 }
84}
85#[cfg(any(feature = "derive", feature = "full"))]
86#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
87impl Eq for crate::BinOp {}
88#[cfg(any(feature = "derive", feature = "full"))]
89#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
90impl PartialEq for crate::BinOp {
91 fn eq(&self, other: &Self) -> bool {
92 match (self, other) {
93 (crate::BinOp::Add(_), crate::BinOp::Add(_)) => true,
94 (crate::BinOp::Sub(_), crate::BinOp::Sub(_)) => true,
95 (crate::BinOp::Mul(_), crate::BinOp::Mul(_)) => true,
96 (crate::BinOp::Div(_), crate::BinOp::Div(_)) => true,
97 (crate::BinOp::Rem(_), crate::BinOp::Rem(_)) => true,
98 (crate::BinOp::And(_), crate::BinOp::And(_)) => true,
99 (crate::BinOp::Or(_), crate::BinOp::Or(_)) => true,
100 (crate::BinOp::BitXor(_), crate::BinOp::BitXor(_)) => true,
101 (crate::BinOp::BitAnd(_), crate::BinOp::BitAnd(_)) => true,
102 (crate::BinOp::BitOr(_), crate::BinOp::BitOr(_)) => true,
103 (crate::BinOp::Shl(_), crate::BinOp::Shl(_)) => true,
104 (crate::BinOp::Shr(_), crate::BinOp::Shr(_)) => true,
105 (crate::BinOp::Eq(_), crate::BinOp::Eq(_)) => true,
106 (crate::BinOp::Lt(_), crate::BinOp::Lt(_)) => true,
107 (crate::BinOp::Le(_), crate::BinOp::Le(_)) => true,
108 (crate::BinOp::Ne(_), crate::BinOp::Ne(_)) => true,
109 (crate::BinOp::Ge(_), crate::BinOp::Ge(_)) => true,
110 (crate::BinOp::Gt(_), crate::BinOp::Gt(_)) => true,
111 (crate::BinOp::AddAssign(_), crate::BinOp::AddAssign(_)) => true,
112 (crate::BinOp::SubAssign(_), crate::BinOp::SubAssign(_)) => true,
113 (crate::BinOp::MulAssign(_), crate::BinOp::MulAssign(_)) => true,
114 (crate::BinOp::DivAssign(_), crate::BinOp::DivAssign(_)) => true,
115 (crate::BinOp::RemAssign(_), crate::BinOp::RemAssign(_)) => true,
116 (crate::BinOp::BitXorAssign(_), crate::BinOp::BitXorAssign(_)) => true,
117 (crate::BinOp::BitAndAssign(_), crate::BinOp::BitAndAssign(_)) => true,
118 (crate::BinOp::BitOrAssign(_), crate::BinOp::BitOrAssign(_)) => true,
119 (crate::BinOp::ShlAssign(_), crate::BinOp::ShlAssign(_)) => true,
120 (crate::BinOp::ShrAssign(_), crate::BinOp::ShrAssign(_)) => true,
121 _ => false,
122 }
123 }
124}
125#[cfg(feature = "full")]
126#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
127impl Eq for crate::Block {}
128#[cfg(feature = "full")]
129#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
130impl PartialEq for crate::Block {
131 fn eq(&self, other: &Self) -> bool {
132 self.stmts == other.stmts
133 }
134}
135#[cfg(feature = "full")]
136#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
137impl Eq for crate::BlockModifiers {}
138#[cfg(feature = "full")]
139#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
140impl PartialEq for crate::BlockModifiers {
141 fn eq(&self, _other: &Self) -> bool {
142 true
143 }
144}
145#[cfg(any(feature = "derive", feature = "full"))]
146#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
147impl Eq for crate::BoundLifetimes {}
148#[cfg(any(feature = "derive", feature = "full"))]
149#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
150impl PartialEq for crate::BoundLifetimes {
151 fn eq(&self, other: &Self) -> bool {
152 self.lifetimes == other.lifetimes
153 }
154}
155#[cfg(feature = "full")]
156#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
157impl Eq for crate::CapturedParam {}
158#[cfg(feature = "full")]
159#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
160impl PartialEq for crate::CapturedParam {
161 fn eq(&self, other: &Self) -> bool {
162 match (self, other) {
163 (
164 crate::CapturedParam::Lifetime(self0),
165 crate::CapturedParam::Lifetime(other0),
166 ) => self0 == other0,
167 (crate::CapturedParam::Ident(self0), crate::CapturedParam::Ident(other0)) => {
168 self0 == other0
169 }
170 _ => false,
171 }
172 }
173}
174#[cfg(feature = "full")]
175#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
176impl Eq for crate::ClosureModifiers {}
177#[cfg(feature = "full")]
178#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
179impl PartialEq for crate::ClosureModifiers {
180 fn eq(&self, _other: &Self) -> bool {
181 true
182 }
183}
184#[cfg(feature = "full")]
185#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
186impl Eq for crate::ConstModifiers {}
187#[cfg(feature = "full")]
188#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
189impl PartialEq for crate::ConstModifiers {
190 fn eq(&self, other: &Self) -> bool {
191 self.defaultness == other.defaultness
192 }
193}
194#[cfg(any(feature = "derive", feature = "full"))]
195#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
196impl Eq for crate::ConstParam {}
197#[cfg(any(feature = "derive", feature = "full"))]
198#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
199impl PartialEq for crate::ConstParam {
200 fn eq(&self, other: &Self) -> bool {
201 self.attrs == other.attrs && self.ident == other.ident && self.ty == other.ty
202 && self.default == other.default
203 }
204}
205#[cfg(any(feature = "derive", feature = "full"))]
206#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
207impl Eq for crate::Constraint {}
208#[cfg(any(feature = "derive", feature = "full"))]
209#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
210impl PartialEq for crate::Constraint {
211 fn eq(&self, other: &Self) -> bool {
212 self.ident == other.ident && self.generics == other.generics
213 && self.bounds == other.bounds
214 }
215}
216#[cfg(feature = "derive")]
217#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
218impl Eq for crate::Data {}
219#[cfg(feature = "derive")]
220#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
221impl PartialEq for crate::Data {
222 fn eq(&self, other: &Self) -> bool {
223 match (self, other) {
224 (crate::Data::Struct(self0), crate::Data::Struct(other0)) => self0 == other0,
225 (crate::Data::Enum(self0), crate::Data::Enum(other0)) => self0 == other0,
226 (crate::Data::Union(self0), crate::Data::Union(other0)) => self0 == other0,
227 _ => false,
228 }
229 }
230}
231#[cfg(feature = "derive")]
232#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
233impl Eq for crate::DataEnum {}
234#[cfg(feature = "derive")]
235#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
236impl PartialEq for crate::DataEnum {
237 fn eq(&self, other: &Self) -> bool {
238 self.variants == other.variants
239 }
240}
241#[cfg(feature = "derive")]
242#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
243impl Eq for crate::DataStruct {}
244#[cfg(feature = "derive")]
245#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
246impl PartialEq for crate::DataStruct {
247 fn eq(&self, other: &Self) -> bool {
248 self.fields == other.fields && self.semi_token == other.semi_token
249 }
250}
251#[cfg(feature = "derive")]
252#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
253impl Eq for crate::DataUnion {}
254#[cfg(feature = "derive")]
255#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
256impl PartialEq for crate::DataUnion {
257 fn eq(&self, other: &Self) -> bool {
258 self.fields == other.fields
259 }
260}
261#[cfg(feature = "derive")]
262#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
263impl Eq for crate::DeriveInput {}
264#[cfg(feature = "derive")]
265#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
266impl PartialEq for crate::DeriveInput {
267 fn eq(&self, other: &Self) -> bool {
268 self.attrs == other.attrs && self.vis == other.vis && self.ident == other.ident
269 && self.generics == other.generics && self.data == other.data
270 }
271}
272#[cfg(any(feature = "derive", feature = "full"))]
273#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
274impl Eq for crate::Expr {}
275#[cfg(any(feature = "derive", feature = "full"))]
276#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
277impl PartialEq for crate::Expr {
278 fn eq(&self, other: &Self) -> bool {
279 match (self, other) {
280 #[cfg(feature = "full")]
281 (crate::Expr::Array(self0), crate::Expr::Array(other0)) => self0 == other0,
282 #[cfg(feature = "full")]
283 (crate::Expr::Assign(self0), crate::Expr::Assign(other0)) => self0 == other0,
284 #[cfg(feature = "full")]
285 (crate::Expr::Async(self0), crate::Expr::Async(other0)) => self0 == other0,
286 #[cfg(feature = "full")]
287 (crate::Expr::Await(self0), crate::Expr::Await(other0)) => self0 == other0,
288 (crate::Expr::Binary(self0), crate::Expr::Binary(other0)) => self0 == other0,
289 #[cfg(feature = "full")]
290 (crate::Expr::Block(self0), crate::Expr::Block(other0)) => self0 == other0,
291 #[cfg(feature = "full")]
292 (crate::Expr::Break(self0), crate::Expr::Break(other0)) => self0 == other0,
293 (crate::Expr::Call(self0), crate::Expr::Call(other0)) => self0 == other0,
294 (crate::Expr::Cast(self0), crate::Expr::Cast(other0)) => self0 == other0,
295 #[cfg(feature = "full")]
296 (crate::Expr::Closure(self0), crate::Expr::Closure(other0)) => {
297 self0 == other0
298 }
299 #[cfg(feature = "full")]
300 (crate::Expr::Const(self0), crate::Expr::Const(other0)) => self0 == other0,
301 #[cfg(feature = "full")]
302 (crate::Expr::Continue(self0), crate::Expr::Continue(other0)) => {
303 self0 == other0
304 }
305 (crate::Expr::Field(self0), crate::Expr::Field(other0)) => self0 == other0,
306 #[cfg(feature = "full")]
307 (crate::Expr::ForLoop(self0), crate::Expr::ForLoop(other0)) => {
308 self0 == other0
309 }
310 (crate::Expr::Group(self0), crate::Expr::Group(other0)) => self0 == other0,
311 #[cfg(feature = "full")]
312 (crate::Expr::If(self0), crate::Expr::If(other0)) => self0 == other0,
313 (crate::Expr::Index(self0), crate::Expr::Index(other0)) => self0 == other0,
314 #[cfg(feature = "full")]
315 (crate::Expr::Infer(self0), crate::Expr::Infer(other0)) => self0 == other0,
316 #[cfg(feature = "full")]
317 (crate::Expr::Let(self0), crate::Expr::Let(other0)) => self0 == other0,
318 (crate::Expr::Lit(self0), crate::Expr::Lit(other0)) => self0 == other0,
319 #[cfg(feature = "full")]
320 (crate::Expr::Loop(self0), crate::Expr::Loop(other0)) => self0 == other0,
321 (crate::Expr::Macro(self0), crate::Expr::Macro(other0)) => self0 == other0,
322 #[cfg(feature = "full")]
323 (crate::Expr::Match(self0), crate::Expr::Match(other0)) => self0 == other0,
324 (crate::Expr::MethodCall(self0), crate::Expr::MethodCall(other0)) => {
325 self0 == other0
326 }
327 (crate::Expr::Paren(self0), crate::Expr::Paren(other0)) => self0 == other0,
328 (crate::Expr::Path(self0), crate::Expr::Path(other0)) => self0 == other0,
329 #[cfg(feature = "full")]
330 (crate::Expr::Range(self0), crate::Expr::Range(other0)) => self0 == other0,
331 #[cfg(feature = "full")]
332 (crate::Expr::RawAddr(self0), crate::Expr::RawAddr(other0)) => {
333 self0 == other0
334 }
335 (crate::Expr::Reference(self0), crate::Expr::Reference(other0)) => {
336 self0 == other0
337 }
338 #[cfg(feature = "full")]
339 (crate::Expr::Repeat(self0), crate::Expr::Repeat(other0)) => self0 == other0,
340 #[cfg(feature = "full")]
341 (crate::Expr::Return(self0), crate::Expr::Return(other0)) => self0 == other0,
342 (crate::Expr::Struct(self0), crate::Expr::Struct(other0)) => self0 == other0,
343 #[cfg(feature = "full")]
344 (crate::Expr::Try(self0), crate::Expr::Try(other0)) => self0 == other0,
345 #[cfg(feature = "full")]
346 (crate::Expr::TryBlock(self0), crate::Expr::TryBlock(other0)) => {
347 self0 == other0
348 }
349 (crate::Expr::Tuple(self0), crate::Expr::Tuple(other0)) => self0 == other0,
350 (crate::Expr::Unary(self0), crate::Expr::Unary(other0)) => self0 == other0,
351 #[cfg(feature = "full")]
352 (crate::Expr::Unsafe(self0), crate::Expr::Unsafe(other0)) => self0 == other0,
353 (crate::Expr::Verbatim(self0), crate::Expr::Verbatim(other0)) => {
354 TokenStreamHelper(self0) == TokenStreamHelper(other0)
355 }
356 #[cfg(feature = "full")]
357 (crate::Expr::While(self0), crate::Expr::While(other0)) => self0 == other0,
358 #[cfg(feature = "full")]
359 (crate::Expr::Yield(self0), crate::Expr::Yield(other0)) => self0 == other0,
360 _ => false,
361 }
362 }
363}
364#[cfg(feature = "full")]
365#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
366impl Eq for crate::ExprArray {}
367#[cfg(feature = "full")]
368#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
369impl PartialEq for crate::ExprArray {
370 fn eq(&self, other: &Self) -> bool {
371 self.attrs == other.attrs && self.elems == other.elems
372 }
373}
374#[cfg(feature = "full")]
375#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
376impl Eq for crate::ExprAssign {}
377#[cfg(feature = "full")]
378#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
379impl PartialEq for crate::ExprAssign {
380 fn eq(&self, other: &Self) -> bool {
381 self.attrs == other.attrs && self.left == other.left && self.right == other.right
382 }
383}
384#[cfg(feature = "full")]
385#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
386impl Eq for crate::ExprAsync {}
387#[cfg(feature = "full")]
388#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
389impl PartialEq for crate::ExprAsync {
390 fn eq(&self, other: &Self) -> bool {
391 self.attrs == other.attrs && self.capture == other.capture
392 && self.modifiers == other.modifiers && self.block == other.block
393 }
394}
395#[cfg(feature = "full")]
396#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
397impl Eq for crate::ExprAwait {}
398#[cfg(feature = "full")]
399#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
400impl PartialEq for crate::ExprAwait {
401 fn eq(&self, other: &Self) -> bool {
402 self.attrs == other.attrs && self.base == other.base
403 }
404}
405#[cfg(any(feature = "derive", feature = "full"))]
406#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
407impl Eq for crate::ExprBinary {}
408#[cfg(any(feature = "derive", feature = "full"))]
409#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
410impl PartialEq for crate::ExprBinary {
411 fn eq(&self, other: &Self) -> bool {
412 self.attrs == other.attrs && self.left == other.left && self.op == other.op
413 && self.right == other.right
414 }
415}
416#[cfg(feature = "full")]
417#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
418impl Eq for crate::ExprBlock {}
419#[cfg(feature = "full")]
420#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
421impl PartialEq for crate::ExprBlock {
422 fn eq(&self, other: &Self) -> bool {
423 self.attrs == other.attrs && self.label == other.label
424 && self.block == other.block
425 }
426}
427#[cfg(feature = "full")]
428#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
429impl Eq for crate::ExprBreak {}
430#[cfg(feature = "full")]
431#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
432impl PartialEq for crate::ExprBreak {
433 fn eq(&self, other: &Self) -> bool {
434 self.attrs == other.attrs && self.label == other.label && self.expr == other.expr
435 }
436}
437#[cfg(any(feature = "derive", feature = "full"))]
438#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
439impl Eq for crate::ExprCall {}
440#[cfg(any(feature = "derive", feature = "full"))]
441#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
442impl PartialEq for crate::ExprCall {
443 fn eq(&self, other: &Self) -> bool {
444 self.attrs == other.attrs && self.func == other.func && self.args == other.args
445 }
446}
447#[cfg(any(feature = "derive", feature = "full"))]
448#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
449impl Eq for crate::ExprCast {}
450#[cfg(any(feature = "derive", feature = "full"))]
451#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
452impl PartialEq for crate::ExprCast {
453 fn eq(&self, other: &Self) -> bool {
454 self.attrs == other.attrs && self.expr == other.expr && self.ty == other.ty
455 }
456}
457#[cfg(feature = "full")]
458#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
459impl Eq for crate::ExprClosure {}
460#[cfg(feature = "full")]
461#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
462impl PartialEq for crate::ExprClosure {
463 fn eq(&self, other: &Self) -> bool {
464 self.attrs == other.attrs && self.lifetimes == other.lifetimes
465 && self.modifiers == other.modifiers && self.constness == other.constness
466 && self.asyncness == other.asyncness && self.capture == other.capture
467 && self.inputs == other.inputs && self.output == other.output
468 && self.body == other.body
469 }
470}
471#[cfg(feature = "full")]
472#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
473impl Eq for crate::ExprConst {}
474#[cfg(feature = "full")]
475#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
476impl PartialEq for crate::ExprConst {
477 fn eq(&self, other: &Self) -> bool {
478 self.attrs == other.attrs && self.modifiers == other.modifiers
479 && self.block == other.block
480 }
481}
482#[cfg(feature = "full")]
483#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
484impl Eq for crate::ExprContinue {}
485#[cfg(feature = "full")]
486#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
487impl PartialEq for crate::ExprContinue {
488 fn eq(&self, other: &Self) -> bool {
489 self.attrs == other.attrs && self.label == other.label
490 }
491}
492#[cfg(any(feature = "derive", feature = "full"))]
493#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
494impl Eq for crate::ExprField {}
495#[cfg(any(feature = "derive", feature = "full"))]
496#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
497impl PartialEq for crate::ExprField {
498 fn eq(&self, other: &Self) -> bool {
499 self.attrs == other.attrs && self.base == other.base
500 && self.member == other.member
501 }
502}
503#[cfg(feature = "full")]
504#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
505impl Eq for crate::ExprForLoop {}
506#[cfg(feature = "full")]
507#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
508impl PartialEq for crate::ExprForLoop {
509 fn eq(&self, other: &Self) -> bool {
510 self.attrs == other.attrs && self.label == other.label && self.pat == other.pat
511 && self.expr == other.expr && self.body == other.body
512 }
513}
514#[cfg(any(feature = "derive", feature = "full"))]
515#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
516impl Eq for crate::ExprGroup {}
517#[cfg(any(feature = "derive", feature = "full"))]
518#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
519impl PartialEq for crate::ExprGroup {
520 fn eq(&self, other: &Self) -> bool {
521 self.attrs == other.attrs && self.expr == other.expr
522 }
523}
524#[cfg(feature = "full")]
525#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
526impl Eq for crate::ExprIf {}
527#[cfg(feature = "full")]
528#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
529impl PartialEq for crate::ExprIf {
530 fn eq(&self, other: &Self) -> bool {
531 self.attrs == other.attrs && self.cond == other.cond
532 && self.then_branch == other.then_branch
533 && self.else_branch == other.else_branch
534 }
535}
536#[cfg(any(feature = "derive", feature = "full"))]
537#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
538impl Eq for crate::ExprIndex {}
539#[cfg(any(feature = "derive", feature = "full"))]
540#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
541impl PartialEq for crate::ExprIndex {
542 fn eq(&self, other: &Self) -> bool {
543 self.attrs == other.attrs && self.expr == other.expr && self.index == other.index
544 }
545}
546#[cfg(feature = "full")]
547#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
548impl Eq for crate::ExprInfer {}
549#[cfg(feature = "full")]
550#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
551impl PartialEq for crate::ExprInfer {
552 fn eq(&self, other: &Self) -> bool {
553 self.attrs == other.attrs
554 }
555}
556#[cfg(feature = "full")]
557#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
558impl Eq for crate::ExprLet {}
559#[cfg(feature = "full")]
560#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
561impl PartialEq for crate::ExprLet {
562 fn eq(&self, other: &Self) -> bool {
563 self.attrs == other.attrs && self.pat == other.pat && self.expr == other.expr
564 }
565}
566#[cfg(any(feature = "derive", feature = "full"))]
567#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
568impl Eq for crate::ExprLit {}
569#[cfg(any(feature = "derive", feature = "full"))]
570#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
571impl PartialEq for crate::ExprLit {
572 fn eq(&self, other: &Self) -> bool {
573 self.attrs == other.attrs && self.lit == other.lit
574 }
575}
576#[cfg(feature = "full")]
577#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
578impl Eq for crate::ExprLoop {}
579#[cfg(feature = "full")]
580#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
581impl PartialEq for crate::ExprLoop {
582 fn eq(&self, other: &Self) -> bool {
583 self.attrs == other.attrs && self.label == other.label && self.body == other.body
584 }
585}
586#[cfg(any(feature = "derive", feature = "full"))]
587#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
588impl Eq for crate::ExprMacro {}
589#[cfg(any(feature = "derive", feature = "full"))]
590#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
591impl PartialEq for crate::ExprMacro {
592 fn eq(&self, other: &Self) -> bool {
593 self.attrs == other.attrs && self.mac == other.mac
594 }
595}
596#[cfg(feature = "full")]
597#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
598impl Eq for crate::ExprMatch {}
599#[cfg(feature = "full")]
600#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
601impl PartialEq for crate::ExprMatch {
602 fn eq(&self, other: &Self) -> bool {
603 self.attrs == other.attrs && self.expr == other.expr && self.arms == other.arms
604 }
605}
606#[cfg(any(feature = "derive", feature = "full"))]
607#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
608impl Eq for crate::ExprMethodCall {}
609#[cfg(any(feature = "derive", feature = "full"))]
610#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
611impl PartialEq for crate::ExprMethodCall {
612 fn eq(&self, other: &Self) -> bool {
613 self.attrs == other.attrs && self.receiver == other.receiver
614 && self.method == other.method && self.turbofish == other.turbofish
615 && self.args == other.args
616 }
617}
618#[cfg(any(feature = "derive", feature = "full"))]
619#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
620impl Eq for crate::ExprParen {}
621#[cfg(any(feature = "derive", feature = "full"))]
622#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
623impl PartialEq for crate::ExprParen {
624 fn eq(&self, other: &Self) -> bool {
625 self.attrs == other.attrs && self.expr == other.expr
626 }
627}
628#[cfg(any(feature = "derive", feature = "full"))]
629#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
630impl Eq for crate::ExprPath {}
631#[cfg(any(feature = "derive", feature = "full"))]
632#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
633impl PartialEq for crate::ExprPath {
634 fn eq(&self, other: &Self) -> bool {
635 self.attrs == other.attrs && self.qself == other.qself && self.path == other.path
636 }
637}
638#[cfg(feature = "full")]
639#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
640impl Eq for crate::ExprRange {}
641#[cfg(feature = "full")]
642#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
643impl PartialEq for crate::ExprRange {
644 fn eq(&self, other: &Self) -> bool {
645 self.attrs == other.attrs && self.start == other.start
646 && self.limits == other.limits && self.end == other.end
647 }
648}
649#[cfg(feature = "full")]
650#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
651impl Eq for crate::ExprRawAddr {}
652#[cfg(feature = "full")]
653#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
654impl PartialEq for crate::ExprRawAddr {
655 fn eq(&self, other: &Self) -> bool {
656 self.attrs == other.attrs && self.mutability == other.mutability
657 && self.expr == other.expr
658 }
659}
660#[cfg(any(feature = "derive", feature = "full"))]
661#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
662impl Eq for crate::ExprReference {}
663#[cfg(any(feature = "derive", feature = "full"))]
664#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
665impl PartialEq for crate::ExprReference {
666 fn eq(&self, other: &Self) -> bool {
667 self.attrs == other.attrs && self.mutability == other.mutability
668 && self.expr == other.expr
669 }
670}
671#[cfg(feature = "full")]
672#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
673impl Eq for crate::ExprRepeat {}
674#[cfg(feature = "full")]
675#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
676impl PartialEq for crate::ExprRepeat {
677 fn eq(&self, other: &Self) -> bool {
678 self.attrs == other.attrs && self.expr == other.expr && self.len == other.len
679 }
680}
681#[cfg(feature = "full")]
682#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
683impl Eq for crate::ExprReturn {}
684#[cfg(feature = "full")]
685#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
686impl PartialEq for crate::ExprReturn {
687 fn eq(&self, other: &Self) -> bool {
688 self.attrs == other.attrs && self.expr == other.expr
689 }
690}
691#[cfg(any(feature = "derive", feature = "full"))]
692#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
693impl Eq for crate::ExprStruct {}
694#[cfg(any(feature = "derive", feature = "full"))]
695#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
696impl PartialEq for crate::ExprStruct {
697 fn eq(&self, other: &Self) -> bool {
698 self.attrs == other.attrs && self.qself == other.qself && self.path == other.path
699 && self.fields == other.fields && self.dot2_token == other.dot2_token
700 && self.rest == other.rest
701 }
702}
703#[cfg(feature = "full")]
704#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
705impl Eq for crate::ExprTry {}
706#[cfg(feature = "full")]
707#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
708impl PartialEq for crate::ExprTry {
709 fn eq(&self, other: &Self) -> bool {
710 self.attrs == other.attrs && self.expr == other.expr
711 }
712}
713#[cfg(feature = "full")]
714#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
715impl Eq for crate::ExprTryBlock {}
716#[cfg(feature = "full")]
717#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
718impl PartialEq for crate::ExprTryBlock {
719 fn eq(&self, other: &Self) -> bool {
720 self.attrs == other.attrs && self.modifiers == other.modifiers
721 && self.block == other.block
722 }
723}
724#[cfg(any(feature = "derive", feature = "full"))]
725#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
726impl Eq for crate::ExprTuple {}
727#[cfg(any(feature = "derive", feature = "full"))]
728#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
729impl PartialEq for crate::ExprTuple {
730 fn eq(&self, other: &Self) -> bool {
731 self.attrs == other.attrs && self.elems == other.elems
732 }
733}
734#[cfg(any(feature = "derive", feature = "full"))]
735#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
736impl Eq for crate::ExprUnary {}
737#[cfg(any(feature = "derive", feature = "full"))]
738#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
739impl PartialEq for crate::ExprUnary {
740 fn eq(&self, other: &Self) -> bool {
741 self.attrs == other.attrs && self.op == other.op && self.expr == other.expr
742 }
743}
744#[cfg(feature = "full")]
745#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
746impl Eq for crate::ExprUnsafe {}
747#[cfg(feature = "full")]
748#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
749impl PartialEq for crate::ExprUnsafe {
750 fn eq(&self, other: &Self) -> bool {
751 self.attrs == other.attrs && self.block == other.block
752 }
753}
754#[cfg(feature = "full")]
755#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
756impl Eq for crate::ExprWhile {}
757#[cfg(feature = "full")]
758#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
759impl PartialEq for crate::ExprWhile {
760 fn eq(&self, other: &Self) -> bool {
761 self.attrs == other.attrs && self.label == other.label && self.cond == other.cond
762 && self.body == other.body
763 }
764}
765#[cfg(feature = "full")]
766#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
767impl Eq for crate::ExprYield {}
768#[cfg(feature = "full")]
769#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
770impl PartialEq for crate::ExprYield {
771 fn eq(&self, other: &Self) -> bool {
772 self.attrs == other.attrs && self.expr == other.expr
773 }
774}
775#[cfg(any(feature = "derive", feature = "full"))]
776#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
777impl Eq for crate::Field {}
778#[cfg(any(feature = "derive", feature = "full"))]
779#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
780impl PartialEq for crate::Field {
781 fn eq(&self, other: &Self) -> bool {
782 self.attrs == other.attrs && self.vis == other.vis
783 && self.modifiers == other.modifiers && self.ident == other.ident
784 && self.colon_token == other.colon_token && self.ty == other.ty
785 && self.default == other.default
786 }
787}
788#[cfg(any(feature = "derive", feature = "full"))]
789#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
790impl Eq for crate::FieldModifiers {}
791#[cfg(any(feature = "derive", feature = "full"))]
792#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
793impl PartialEq for crate::FieldModifiers {
794 fn eq(&self, _other: &Self) -> bool {
795 true
796 }
797}
798#[cfg(feature = "full")]
799#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
800impl Eq for crate::FieldPat {}
801#[cfg(feature = "full")]
802#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
803impl PartialEq for crate::FieldPat {
804 fn eq(&self, other: &Self) -> bool {
805 self.attrs == other.attrs && self.member == other.member
806 && self.colon_token == other.colon_token && self.pat == other.pat
807 }
808}
809#[cfg(any(feature = "derive", feature = "full"))]
810#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
811impl Eq for crate::FieldValue {}
812#[cfg(any(feature = "derive", feature = "full"))]
813#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
814impl PartialEq for crate::FieldValue {
815 fn eq(&self, other: &Self) -> bool {
816 self.attrs == other.attrs && self.member == other.member
817 && self.colon_token == other.colon_token && self.expr == other.expr
818 }
819}
820#[cfg(any(feature = "derive", feature = "full"))]
821#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
822impl Eq for crate::Fields {}
823#[cfg(any(feature = "derive", feature = "full"))]
824#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
825impl PartialEq for crate::Fields {
826 fn eq(&self, other: &Self) -> bool {
827 match (self, other) {
828 (crate::Fields::Named(self0), crate::Fields::Named(other0)) => {
829 self0 == other0
830 }
831 (crate::Fields::Unnamed(self0), crate::Fields::Unnamed(other0)) => {
832 self0 == other0
833 }
834 (crate::Fields::Unit, crate::Fields::Unit) => true,
835 _ => false,
836 }
837 }
838}
839#[cfg(any(feature = "derive", feature = "full"))]
840#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
841impl Eq for crate::FieldsNamed {}
842#[cfg(any(feature = "derive", feature = "full"))]
843#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
844impl PartialEq for crate::FieldsNamed {
845 fn eq(&self, other: &Self) -> bool {
846 self.named == other.named
847 }
848}
849#[cfg(any(feature = "derive", feature = "full"))]
850#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
851impl Eq for crate::FieldsUnnamed {}
852#[cfg(any(feature = "derive", feature = "full"))]
853#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
854impl PartialEq for crate::FieldsUnnamed {
855 fn eq(&self, other: &Self) -> bool {
856 self.unnamed == other.unnamed
857 }
858}
859#[cfg(feature = "full")]
860#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
861impl Eq for crate::File {}
862#[cfg(feature = "full")]
863#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
864impl PartialEq for crate::File {
865 fn eq(&self, other: &Self) -> bool {
866 self.shebang == other.shebang && self.frontmatter == other.frontmatter
867 && self.attrs == other.attrs && self.items == other.items
868 }
869}
870#[cfg(feature = "full")]
871#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
872impl Eq for crate::FnArg {}
873#[cfg(feature = "full")]
874#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
875impl PartialEq for crate::FnArg {
876 fn eq(&self, other: &Self) -> bool {
877 match (self, other) {
878 (crate::FnArg::Receiver(self0), crate::FnArg::Receiver(other0)) => {
879 self0 == other0
880 }
881 (crate::FnArg::Typed(self0), crate::FnArg::Typed(other0)) => self0 == other0,
882 _ => false,
883 }
884 }
885}
886#[cfg(feature = "full")]
887#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
888impl Eq for crate::FnModifiers {}
889#[cfg(feature = "full")]
890#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
891impl PartialEq for crate::FnModifiers {
892 fn eq(&self, other: &Self) -> bool {
893 self.defaultness == other.defaultness
894 }
895}
896#[cfg(any(feature = "derive", feature = "full"))]
897#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
898impl Eq for crate::FnPtrVariadic {}
899#[cfg(any(feature = "derive", feature = "full"))]
900#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
901impl PartialEq for crate::FnPtrVariadic {
902 fn eq(&self, other: &Self) -> bool {
903 self.attrs == other.attrs && self.name == other.name && self.comma == other.comma
904 }
905}
906#[cfg(feature = "full")]
907#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
908impl Eq for crate::ForeignItem {}
909#[cfg(feature = "full")]
910#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
911impl PartialEq for crate::ForeignItem {
912 fn eq(&self, other: &Self) -> bool {
913 match (self, other) {
914 (crate::ForeignItem::Fn(self0), crate::ForeignItem::Fn(other0)) => {
915 self0 == other0
916 }
917 (crate::ForeignItem::Static(self0), crate::ForeignItem::Static(other0)) => {
918 self0 == other0
919 }
920 (crate::ForeignItem::Type(self0), crate::ForeignItem::Type(other0)) => {
921 self0 == other0
922 }
923 (crate::ForeignItem::Macro(self0), crate::ForeignItem::Macro(other0)) => {
924 self0 == other0
925 }
926 (
927 crate::ForeignItem::Verbatim(self0),
928 crate::ForeignItem::Verbatim(other0),
929 ) => TokenStreamHelper(self0) == TokenStreamHelper(other0),
930 _ => false,
931 }
932 }
933}
934#[cfg(feature = "full")]
935#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
936impl Eq for crate::ForeignItemFn {}
937#[cfg(feature = "full")]
938#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
939impl PartialEq for crate::ForeignItemFn {
940 fn eq(&self, other: &Self) -> bool {
941 self.attrs == other.attrs && self.vis == other.vis
942 && self.modifiers == other.modifiers && self.sig == other.sig
943 }
944}
945#[cfg(feature = "full")]
946#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
947impl Eq for crate::ForeignItemMacro {}
948#[cfg(feature = "full")]
949#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
950impl PartialEq for crate::ForeignItemMacro {
951 fn eq(&self, other: &Self) -> bool {
952 self.attrs == other.attrs && self.mac == other.mac
953 && self.semi_token == other.semi_token
954 }
955}
956#[cfg(feature = "full")]
957#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
958impl Eq for crate::ForeignItemStatic {}
959#[cfg(feature = "full")]
960#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
961impl PartialEq for crate::ForeignItemStatic {
962 fn eq(&self, other: &Self) -> bool {
963 self.attrs == other.attrs && self.vis == other.vis && self.safety == other.safety
964 && self.mutability == other.mutability && self.ident == other.ident
965 && self.ty == other.ty
966 }
967}
968#[cfg(feature = "full")]
969#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
970impl Eq for crate::ForeignItemType {}
971#[cfg(feature = "full")]
972#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
973impl PartialEq for crate::ForeignItemType {
974 fn eq(&self, other: &Self) -> bool {
975 self.attrs == other.attrs && self.vis == other.vis
976 && self.modifiers == other.modifiers && self.ident == other.ident
977 && self.generics == other.generics
978 }
979}
980#[cfg(feature = "full")]
981#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
982impl Eq for crate::Frontmatter {}
983#[cfg(feature = "full")]
984#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
985impl PartialEq for crate::Frontmatter {
986 fn eq(&self, _other: &Self) -> bool {
987 true
988 }
989}
990#[cfg(any(feature = "derive", feature = "full"))]
991#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
992impl Eq for crate::GenericArgument {}
993#[cfg(any(feature = "derive", feature = "full"))]
994#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
995impl PartialEq for crate::GenericArgument {
996 fn eq(&self, other: &Self) -> bool {
997 match (self, other) {
998 (
999 crate::GenericArgument::Lifetime(self0),
1000 crate::GenericArgument::Lifetime(other0),
1001 ) => self0 == other0,
1002 (
1003 crate::GenericArgument::Type(self0),
1004 crate::GenericArgument::Type(other0),
1005 ) => self0 == other0,
1006 (
1007 crate::GenericArgument::Const(self0),
1008 crate::GenericArgument::Const(other0),
1009 ) => self0 == other0,
1010 (
1011 crate::GenericArgument::AssocType(self0),
1012 crate::GenericArgument::AssocType(other0),
1013 ) => self0 == other0,
1014 (
1015 crate::GenericArgument::AssocConst(self0),
1016 crate::GenericArgument::AssocConst(other0),
1017 ) => self0 == other0,
1018 (
1019 crate::GenericArgument::Constraint(self0),
1020 crate::GenericArgument::Constraint(other0),
1021 ) => self0 == other0,
1022 _ => false,
1023 }
1024 }
1025}
1026#[cfg(any(feature = "derive", feature = "full"))]
1027#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1028impl Eq for crate::GenericParam {}
1029#[cfg(any(feature = "derive", feature = "full"))]
1030#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1031impl PartialEq for crate::GenericParam {
1032 fn eq(&self, other: &Self) -> bool {
1033 match (self, other) {
1034 (
1035 crate::GenericParam::Lifetime(self0),
1036 crate::GenericParam::Lifetime(other0),
1037 ) => self0 == other0,
1038 (crate::GenericParam::Type(self0), crate::GenericParam::Type(other0)) => {
1039 self0 == other0
1040 }
1041 (crate::GenericParam::Const(self0), crate::GenericParam::Const(other0)) => {
1042 self0 == other0
1043 }
1044 _ => false,
1045 }
1046 }
1047}
1048#[cfg(any(feature = "derive", feature = "full"))]
1049#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1050impl Eq for crate::Generics {}
1051#[cfg(any(feature = "derive", feature = "full"))]
1052#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1053impl PartialEq for crate::Generics {
1054 fn eq(&self, other: &Self) -> bool {
1055 self.lt_token == other.lt_token && self.params == other.params
1056 && self.gt_token == other.gt_token && self.where_clause == other.where_clause
1057 }
1058}
1059#[cfg(feature = "full")]
1060#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1061impl Eq for crate::ImplItem {}
1062#[cfg(feature = "full")]
1063#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1064impl PartialEq for crate::ImplItem {
1065 fn eq(&self, other: &Self) -> bool {
1066 match (self, other) {
1067 (crate::ImplItem::Const(self0), crate::ImplItem::Const(other0)) => {
1068 self0 == other0
1069 }
1070 (crate::ImplItem::Fn(self0), crate::ImplItem::Fn(other0)) => self0 == other0,
1071 (crate::ImplItem::Type(self0), crate::ImplItem::Type(other0)) => {
1072 self0 == other0
1073 }
1074 (crate::ImplItem::Macro(self0), crate::ImplItem::Macro(other0)) => {
1075 self0 == other0
1076 }
1077 (crate::ImplItem::Verbatim(self0), crate::ImplItem::Verbatim(other0)) => {
1078 TokenStreamHelper(self0) == TokenStreamHelper(other0)
1079 }
1080 _ => false,
1081 }
1082 }
1083}
1084#[cfg(feature = "full")]
1085#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1086impl Eq for crate::ImplItemConst {}
1087#[cfg(feature = "full")]
1088#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1089impl PartialEq for crate::ImplItemConst {
1090 fn eq(&self, other: &Self) -> bool {
1091 self.attrs == other.attrs && self.vis == other.vis
1092 && self.modifiers == other.modifiers && self.ident == other.ident
1093 && self.generics == other.generics && self.ty == other.ty
1094 && self.expr == other.expr
1095 }
1096}
1097#[cfg(feature = "full")]
1098#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1099impl Eq for crate::ImplItemFn {}
1100#[cfg(feature = "full")]
1101#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1102impl PartialEq for crate::ImplItemFn {
1103 fn eq(&self, other: &Self) -> bool {
1104 self.attrs == other.attrs && self.vis == other.vis
1105 && self.modifiers == other.modifiers && self.sig == other.sig
1106 && self.block == other.block
1107 }
1108}
1109#[cfg(feature = "full")]
1110#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1111impl Eq for crate::ImplItemMacro {}
1112#[cfg(feature = "full")]
1113#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1114impl PartialEq for crate::ImplItemMacro {
1115 fn eq(&self, other: &Self) -> bool {
1116 self.attrs == other.attrs && self.mac == other.mac
1117 && self.semi_token == other.semi_token
1118 }
1119}
1120#[cfg(feature = "full")]
1121#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1122impl Eq for crate::ImplItemType {}
1123#[cfg(feature = "full")]
1124#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1125impl PartialEq for crate::ImplItemType {
1126 fn eq(&self, other: &Self) -> bool {
1127 self.attrs == other.attrs && self.vis == other.vis
1128 && self.modifiers == other.modifiers && self.ident == other.ident
1129 && self.generics == other.generics && self.ty == other.ty
1130 }
1131}
1132#[cfg(feature = "full")]
1133#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1134impl Eq for crate::ImplModifiers {}
1135#[cfg(feature = "full")]
1136#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1137impl PartialEq for crate::ImplModifiers {
1138 fn eq(&self, other: &Self) -> bool {
1139 self.defaultness == other.defaultness && self.polarity == other.polarity
1140 }
1141}
1142#[cfg(feature = "full")]
1143#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1144impl Eq for crate::Item {}
1145#[cfg(feature = "full")]
1146#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1147impl PartialEq for crate::Item {
1148 fn eq(&self, other: &Self) -> bool {
1149 match (self, other) {
1150 (crate::Item::Const(self0), crate::Item::Const(other0)) => self0 == other0,
1151 (crate::Item::Enum(self0), crate::Item::Enum(other0)) => self0 == other0,
1152 (crate::Item::ExternCrate(self0), crate::Item::ExternCrate(other0)) => {
1153 self0 == other0
1154 }
1155 (crate::Item::Fn(self0), crate::Item::Fn(other0)) => self0 == other0,
1156 (crate::Item::ForeignMod(self0), crate::Item::ForeignMod(other0)) => {
1157 self0 == other0
1158 }
1159 (crate::Item::Impl(self0), crate::Item::Impl(other0)) => self0 == other0,
1160 (crate::Item::Macro(self0), crate::Item::Macro(other0)) => self0 == other0,
1161 (crate::Item::Mod(self0), crate::Item::Mod(other0)) => self0 == other0,
1162 (crate::Item::Static(self0), crate::Item::Static(other0)) => self0 == other0,
1163 (crate::Item::Struct(self0), crate::Item::Struct(other0)) => self0 == other0,
1164 (crate::Item::Trait(self0), crate::Item::Trait(other0)) => self0 == other0,
1165 (crate::Item::TraitAlias(self0), crate::Item::TraitAlias(other0)) => {
1166 self0 == other0
1167 }
1168 (crate::Item::Type(self0), crate::Item::Type(other0)) => self0 == other0,
1169 (crate::Item::Union(self0), crate::Item::Union(other0)) => self0 == other0,
1170 (crate::Item::Use(self0), crate::Item::Use(other0)) => self0 == other0,
1171 (crate::Item::Verbatim(self0), crate::Item::Verbatim(other0)) => {
1172 TokenStreamHelper(self0) == TokenStreamHelper(other0)
1173 }
1174 _ => false,
1175 }
1176 }
1177}
1178#[cfg(feature = "full")]
1179#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1180impl Eq for crate::ItemConst {}
1181#[cfg(feature = "full")]
1182#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1183impl PartialEq for crate::ItemConst {
1184 fn eq(&self, other: &Self) -> bool {
1185 self.attrs == other.attrs && self.vis == other.vis
1186 && self.modifiers == other.modifiers && self.ident == other.ident
1187 && self.generics == other.generics && self.ty == other.ty
1188 && self.expr == other.expr
1189 }
1190}
1191#[cfg(feature = "full")]
1192#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1193impl Eq for crate::ItemEnum {}
1194#[cfg(feature = "full")]
1195#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1196impl PartialEq for crate::ItemEnum {
1197 fn eq(&self, other: &Self) -> bool {
1198 self.attrs == other.attrs && self.vis == other.vis && self.ident == other.ident
1199 && self.generics == other.generics && self.variants == other.variants
1200 }
1201}
1202#[cfg(feature = "full")]
1203#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1204impl Eq for crate::ItemExternCrate {}
1205#[cfg(feature = "full")]
1206#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1207impl PartialEq for crate::ItemExternCrate {
1208 fn eq(&self, other: &Self) -> bool {
1209 self.attrs == other.attrs && self.vis == other.vis && self.ident == other.ident
1210 && self.rename == other.rename
1211 }
1212}
1213#[cfg(feature = "full")]
1214#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1215impl Eq for crate::ItemFn {}
1216#[cfg(feature = "full")]
1217#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1218impl PartialEq for crate::ItemFn {
1219 fn eq(&self, other: &Self) -> bool {
1220 self.attrs == other.attrs && self.vis == other.vis
1221 && self.modifiers == other.modifiers && self.sig == other.sig
1222 && self.block == other.block
1223 }
1224}
1225#[cfg(feature = "full")]
1226#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1227impl Eq for crate::ItemForeignMod {}
1228#[cfg(feature = "full")]
1229#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1230impl PartialEq for crate::ItemForeignMod {
1231 fn eq(&self, other: &Self) -> bool {
1232 self.attrs == other.attrs && self.unsafety == other.unsafety
1233 && self.abi == other.abi && self.items == other.items
1234 }
1235}
1236#[cfg(feature = "full")]
1237#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1238impl Eq for crate::ItemImpl {}
1239#[cfg(feature = "full")]
1240#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1241impl PartialEq for crate::ItemImpl {
1242 fn eq(&self, other: &Self) -> bool {
1243 self.attrs == other.attrs && self.modifiers == other.modifiers
1244 && self.unsafety == other.unsafety && self.generics == other.generics
1245 && self.trait_ == other.trait_ && self.self_ty == other.self_ty
1246 && self.items == other.items
1247 }
1248}
1249#[cfg(feature = "full")]
1250#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1251impl Eq for crate::ItemMacro {}
1252#[cfg(feature = "full")]
1253#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1254impl PartialEq for crate::ItemMacro {
1255 fn eq(&self, other: &Self) -> bool {
1256 self.attrs == other.attrs && self.ident == other.ident && self.mac == other.mac
1257 && self.semi_token == other.semi_token
1258 }
1259}
1260#[cfg(feature = "full")]
1261#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1262impl Eq for crate::ItemMod {}
1263#[cfg(feature = "full")]
1264#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1265impl PartialEq for crate::ItemMod {
1266 fn eq(&self, other: &Self) -> bool {
1267 self.attrs == other.attrs && self.vis == other.vis
1268 && self.unsafety == other.unsafety && self.ident == other.ident
1269 && self.content == other.content && self.semi == other.semi
1270 }
1271}
1272#[cfg(feature = "full")]
1273#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1274impl Eq for crate::ItemStatic {}
1275#[cfg(feature = "full")]
1276#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1277impl PartialEq for crate::ItemStatic {
1278 fn eq(&self, other: &Self) -> bool {
1279 self.attrs == other.attrs && self.vis == other.vis
1280 && self.mutability == other.mutability && self.ident == other.ident
1281 && self.ty == other.ty && self.expr == other.expr
1282 }
1283}
1284#[cfg(feature = "full")]
1285#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1286impl Eq for crate::ItemStruct {}
1287#[cfg(feature = "full")]
1288#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1289impl PartialEq for crate::ItemStruct {
1290 fn eq(&self, other: &Self) -> bool {
1291 self.attrs == other.attrs && self.vis == other.vis && self.ident == other.ident
1292 && self.generics == other.generics && self.fields == other.fields
1293 && self.semi_token == other.semi_token
1294 }
1295}
1296#[cfg(feature = "full")]
1297#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1298impl Eq for crate::ItemTrait {}
1299#[cfg(feature = "full")]
1300#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1301impl PartialEq for crate::ItemTrait {
1302 fn eq(&self, other: &Self) -> bool {
1303 self.attrs == other.attrs && self.vis == other.vis
1304 && self.modifiers == other.modifiers && self.unsafety == other.unsafety
1305 && self.ident == other.ident && self.generics == other.generics
1306 && self.colon_token == other.colon_token
1307 && self.supertraits == other.supertraits && self.items == other.items
1308 }
1309}
1310#[cfg(feature = "full")]
1311#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1312impl Eq for crate::ItemTraitAlias {}
1313#[cfg(feature = "full")]
1314#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1315impl PartialEq for crate::ItemTraitAlias {
1316 fn eq(&self, other: &Self) -> bool {
1317 self.attrs == other.attrs && self.vis == other.vis && self.ident == other.ident
1318 && self.generics == other.generics && self.bounds == other.bounds
1319 }
1320}
1321#[cfg(feature = "full")]
1322#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1323impl Eq for crate::ItemType {}
1324#[cfg(feature = "full")]
1325#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1326impl PartialEq for crate::ItemType {
1327 fn eq(&self, other: &Self) -> bool {
1328 self.attrs == other.attrs && self.vis == other.vis
1329 && self.modifiers == other.modifiers && self.ident == other.ident
1330 && self.generics == other.generics && self.ty == other.ty
1331 && self.where_clause_placement == other.where_clause_placement
1332 }
1333}
1334#[cfg(feature = "full")]
1335#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1336impl Eq for crate::ItemUnion {}
1337#[cfg(feature = "full")]
1338#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1339impl PartialEq for crate::ItemUnion {
1340 fn eq(&self, other: &Self) -> bool {
1341 self.attrs == other.attrs && self.vis == other.vis && self.ident == other.ident
1342 && self.generics == other.generics && self.fields == other.fields
1343 }
1344}
1345#[cfg(feature = "full")]
1346#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1347impl Eq for crate::ItemUse {}
1348#[cfg(feature = "full")]
1349#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1350impl PartialEq for crate::ItemUse {
1351 fn eq(&self, other: &Self) -> bool {
1352 self.attrs == other.attrs && self.vis == other.vis
1353 && self.leading_colon == other.leading_colon && self.tree == other.tree
1354 }
1355}
1356#[cfg(feature = "full")]
1357#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1358impl Eq for crate::Label {}
1359#[cfg(feature = "full")]
1360#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1361impl PartialEq for crate::Label {
1362 fn eq(&self, other: &Self) -> bool {
1363 self.name == other.name
1364 }
1365}
1366#[cfg(any(feature = "derive", feature = "full"))]
1367#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1368impl Eq for crate::LifetimeParam {}
1369#[cfg(any(feature = "derive", feature = "full"))]
1370#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1371impl PartialEq for crate::LifetimeParam {
1372 fn eq(&self, other: &Self) -> bool {
1373 self.attrs == other.attrs && self.lifetime == other.lifetime
1374 && self.colon_token == other.colon_token && self.bounds == other.bounds
1375 }
1376}
1377#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1378impl Eq for crate::Lit {}
1379#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1380impl PartialEq for crate::Lit {
1381 fn eq(&self, other: &Self) -> bool {
1382 match (self, other) {
1383 (crate::Lit::Str(self0), crate::Lit::Str(other0)) => self0 == other0,
1384 (crate::Lit::ByteStr(self0), crate::Lit::ByteStr(other0)) => self0 == other0,
1385 (crate::Lit::CStr(self0), crate::Lit::CStr(other0)) => self0 == other0,
1386 (crate::Lit::Byte(self0), crate::Lit::Byte(other0)) => self0 == other0,
1387 (crate::Lit::Char(self0), crate::Lit::Char(other0)) => self0 == other0,
1388 (crate::Lit::Int(self0), crate::Lit::Int(other0)) => self0 == other0,
1389 (crate::Lit::Float(self0), crate::Lit::Float(other0)) => self0 == other0,
1390 (crate::Lit::Bool(self0), crate::Lit::Bool(other0)) => self0 == other0,
1391 (crate::Lit::Verbatim(self0), crate::Lit::Verbatim(other0)) => {
1392 self0.to_string() == other0.to_string()
1393 }
1394 _ => false,
1395 }
1396 }
1397}
1398#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1399impl Eq for crate::LitBool {}
1400#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1401impl PartialEq for crate::LitBool {
1402 fn eq(&self, other: &Self) -> bool {
1403 self.value == other.value
1404 }
1405}
1406#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1407impl Eq for crate::LitByte {}
1408#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1409impl Eq for crate::LitByteStr {}
1410#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1411impl Eq for crate::LitCStr {}
1412#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1413impl Eq for crate::LitChar {}
1414#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1415impl Eq for crate::LitFloat {}
1416#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1417impl Eq for crate::LitInt {}
1418#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1419impl Eq for crate::LitStr {}
1420#[cfg(feature = "full")]
1421#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1422impl Eq for crate::Local {}
1423#[cfg(feature = "full")]
1424#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1425impl PartialEq for crate::Local {
1426 fn eq(&self, other: &Self) -> bool {
1427 self.attrs == other.attrs && self.modifiers == other.modifiers
1428 && self.pat == other.pat && self.init == other.init
1429 }
1430}
1431#[cfg(feature = "full")]
1432#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1433impl Eq for crate::LocalInit {}
1434#[cfg(feature = "full")]
1435#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1436impl PartialEq for crate::LocalInit {
1437 fn eq(&self, other: &Self) -> bool {
1438 self.expr == other.expr && self.diverge == other.diverge
1439 }
1440}
1441#[cfg(feature = "full")]
1442#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1443impl Eq for crate::LocalModifiers {}
1444#[cfg(feature = "full")]
1445#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1446impl PartialEq for crate::LocalModifiers {
1447 fn eq(&self, _other: &Self) -> bool {
1448 true
1449 }
1450}
1451#[cfg(any(feature = "derive", feature = "full"))]
1452#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1453impl Eq for crate::Macro {}
1454#[cfg(any(feature = "derive", feature = "full"))]
1455#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1456impl PartialEq for crate::Macro {
1457 fn eq(&self, other: &Self) -> bool {
1458 self.path == other.path && self.delimiter == other.delimiter
1459 && TokenStreamHelper(&self.tokens) == TokenStreamHelper(&other.tokens)
1460 }
1461}
1462#[cfg(any(feature = "derive", feature = "full"))]
1463#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1464impl Eq for crate::MacroDelimiter {}
1465#[cfg(any(feature = "derive", feature = "full"))]
1466#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1467impl PartialEq for crate::MacroDelimiter {
1468 fn eq(&self, other: &Self) -> bool {
1469 match (self, other) {
1470 (crate::MacroDelimiter::Paren(_), crate::MacroDelimiter::Paren(_)) => true,
1471 (crate::MacroDelimiter::Brace(_), crate::MacroDelimiter::Brace(_)) => true,
1472 (crate::MacroDelimiter::Bracket(_), crate::MacroDelimiter::Bracket(_)) => {
1473 true
1474 }
1475 _ => false,
1476 }
1477 }
1478}
1479#[cfg(any(feature = "derive", feature = "full"))]
1480#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1481impl Eq for crate::Meta {}
1482#[cfg(any(feature = "derive", feature = "full"))]
1483#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1484impl PartialEq for crate::Meta {
1485 fn eq(&self, other: &Self) -> bool {
1486 match (self, other) {
1487 (crate::Meta::Path(self0), crate::Meta::Path(other0)) => self0 == other0,
1488 (crate::Meta::List(self0), crate::Meta::List(other0)) => self0 == other0,
1489 (crate::Meta::NameValue(self0), crate::Meta::NameValue(other0)) => {
1490 self0 == other0
1491 }
1492 _ => false,
1493 }
1494 }
1495}
1496#[cfg(any(feature = "derive", feature = "full"))]
1497#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1498impl Eq for crate::MetaList {}
1499#[cfg(any(feature = "derive", feature = "full"))]
1500#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1501impl PartialEq for crate::MetaList {
1502 fn eq(&self, other: &Self) -> bool {
1503 self.path == other.path && self.delimiter == other.delimiter
1504 && TokenStreamHelper(&self.tokens) == TokenStreamHelper(&other.tokens)
1505 }
1506}
1507#[cfg(any(feature = "derive", feature = "full"))]
1508#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1509impl Eq for crate::MetaNameValue {}
1510#[cfg(any(feature = "derive", feature = "full"))]
1511#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1512impl PartialEq for crate::MetaNameValue {
1513 fn eq(&self, other: &Self) -> bool {
1514 self.path == other.path && self.value == other.value
1515 }
1516}
1517#[cfg(any(feature = "derive", feature = "full"))]
1518#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1519impl Eq for crate::NamedArg {}
1520#[cfg(any(feature = "derive", feature = "full"))]
1521#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1522impl PartialEq for crate::NamedArg {
1523 fn eq(&self, other: &Self) -> bool {
1524 self.attrs == other.attrs && self.name == other.name && self.ty == other.ty
1525 }
1526}
1527#[cfg(any(feature = "derive", feature = "full"))]
1528#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1529impl Eq for crate::ParenthesizedGenericArguments {}
1530#[cfg(any(feature = "derive", feature = "full"))]
1531#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1532impl PartialEq for crate::ParenthesizedGenericArguments {
1533 fn eq(&self, other: &Self) -> bool {
1534 self.inputs == other.inputs && self.output == other.output
1535 }
1536}
1537#[cfg(feature = "full")]
1538#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1539impl Eq for crate::Pat {}
1540#[cfg(feature = "full")]
1541#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1542impl PartialEq for crate::Pat {
1543 fn eq(&self, other: &Self) -> bool {
1544 match (self, other) {
1545 (crate::Pat::Const(self0), crate::Pat::Const(other0)) => self0 == other0,
1546 (crate::Pat::Guard(self0), crate::Pat::Guard(other0)) => self0 == other0,
1547 (crate::Pat::Ident(self0), crate::Pat::Ident(other0)) => self0 == other0,
1548 (crate::Pat::Lit(self0), crate::Pat::Lit(other0)) => self0 == other0,
1549 (crate::Pat::Macro(self0), crate::Pat::Macro(other0)) => self0 == other0,
1550 (crate::Pat::Or(self0), crate::Pat::Or(other0)) => self0 == other0,
1551 (crate::Pat::Paren(self0), crate::Pat::Paren(other0)) => self0 == other0,
1552 (crate::Pat::Path(self0), crate::Pat::Path(other0)) => self0 == other0,
1553 (crate::Pat::Range(self0), crate::Pat::Range(other0)) => self0 == other0,
1554 (crate::Pat::Reference(self0), crate::Pat::Reference(other0)) => {
1555 self0 == other0
1556 }
1557 (crate::Pat::Rest(self0), crate::Pat::Rest(other0)) => self0 == other0,
1558 (crate::Pat::Slice(self0), crate::Pat::Slice(other0)) => self0 == other0,
1559 (crate::Pat::Struct(self0), crate::Pat::Struct(other0)) => self0 == other0,
1560 (crate::Pat::Tuple(self0), crate::Pat::Tuple(other0)) => self0 == other0,
1561 (crate::Pat::TupleStruct(self0), crate::Pat::TupleStruct(other0)) => {
1562 self0 == other0
1563 }
1564 (crate::Pat::Type(self0), crate::Pat::Type(other0)) => self0 == other0,
1565 (crate::Pat::Verbatim(self0), crate::Pat::Verbatim(other0)) => {
1566 TokenStreamHelper(self0) == TokenStreamHelper(other0)
1567 }
1568 (crate::Pat::Wild(self0), crate::Pat::Wild(other0)) => self0 == other0,
1569 _ => false,
1570 }
1571 }
1572}
1573#[cfg(feature = "full")]
1574#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1575impl Eq for crate::PatGuard {}
1576#[cfg(feature = "full")]
1577#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1578impl PartialEq for crate::PatGuard {
1579 fn eq(&self, other: &Self) -> bool {
1580 self.attrs == other.attrs && self.pat == other.pat && self.guard == other.guard
1581 }
1582}
1583#[cfg(feature = "full")]
1584#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1585impl Eq for crate::PatIdent {}
1586#[cfg(feature = "full")]
1587#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1588impl PartialEq for crate::PatIdent {
1589 fn eq(&self, other: &Self) -> bool {
1590 self.attrs == other.attrs && self.by_ref == other.by_ref
1591 && self.mutability == other.mutability && self.ident == other.ident
1592 && self.subpat == other.subpat
1593 }
1594}
1595#[cfg(feature = "full")]
1596#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1597impl Eq for crate::PatOr {}
1598#[cfg(feature = "full")]
1599#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1600impl PartialEq for crate::PatOr {
1601 fn eq(&self, other: &Self) -> bool {
1602 self.attrs == other.attrs && self.leading_vert == other.leading_vert
1603 && self.cases == other.cases
1604 }
1605}
1606#[cfg(feature = "full")]
1607#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1608impl Eq for crate::PatParen {}
1609#[cfg(feature = "full")]
1610#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1611impl PartialEq for crate::PatParen {
1612 fn eq(&self, other: &Self) -> bool {
1613 self.attrs == other.attrs && self.pat == other.pat
1614 }
1615}
1616#[cfg(feature = "full")]
1617#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1618impl Eq for crate::PatReference {}
1619#[cfg(feature = "full")]
1620#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1621impl PartialEq for crate::PatReference {
1622 fn eq(&self, other: &Self) -> bool {
1623 self.attrs == other.attrs && self.mutability == other.mutability
1624 && self.pat == other.pat
1625 }
1626}
1627#[cfg(feature = "full")]
1628#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1629impl Eq for crate::PatRest {}
1630#[cfg(feature = "full")]
1631#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1632impl PartialEq for crate::PatRest {
1633 fn eq(&self, other: &Self) -> bool {
1634 self.attrs == other.attrs
1635 }
1636}
1637#[cfg(feature = "full")]
1638#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1639impl Eq for crate::PatSlice {}
1640#[cfg(feature = "full")]
1641#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1642impl PartialEq for crate::PatSlice {
1643 fn eq(&self, other: &Self) -> bool {
1644 self.attrs == other.attrs && self.elems == other.elems
1645 }
1646}
1647#[cfg(feature = "full")]
1648#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1649impl Eq for crate::PatStruct {}
1650#[cfg(feature = "full")]
1651#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1652impl PartialEq for crate::PatStruct {
1653 fn eq(&self, other: &Self) -> bool {
1654 self.attrs == other.attrs && self.qself == other.qself && self.path == other.path
1655 && self.fields == other.fields && self.rest == other.rest
1656 }
1657}
1658#[cfg(feature = "full")]
1659#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1660impl Eq for crate::PatTuple {}
1661#[cfg(feature = "full")]
1662#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1663impl PartialEq for crate::PatTuple {
1664 fn eq(&self, other: &Self) -> bool {
1665 self.attrs == other.attrs && self.elems == other.elems
1666 }
1667}
1668#[cfg(feature = "full")]
1669#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1670impl Eq for crate::PatTupleStruct {}
1671#[cfg(feature = "full")]
1672#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1673impl PartialEq for crate::PatTupleStruct {
1674 fn eq(&self, other: &Self) -> bool {
1675 self.attrs == other.attrs && self.qself == other.qself && self.path == other.path
1676 && self.elems == other.elems
1677 }
1678}
1679#[cfg(feature = "full")]
1680#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1681impl Eq for crate::PatType {}
1682#[cfg(feature = "full")]
1683#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1684impl PartialEq for crate::PatType {
1685 fn eq(&self, other: &Self) -> bool {
1686 self.attrs == other.attrs && self.pat == other.pat && self.ty == other.ty
1687 }
1688}
1689#[cfg(feature = "full")]
1690#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1691impl Eq for crate::PatWild {}
1692#[cfg(feature = "full")]
1693#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1694impl PartialEq for crate::PatWild {
1695 fn eq(&self, other: &Self) -> bool {
1696 self.attrs == other.attrs
1697 }
1698}
1699#[cfg(any(feature = "derive", feature = "full"))]
1700#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1701impl Eq for crate::Path {}
1702#[cfg(any(feature = "derive", feature = "full"))]
1703#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1704impl PartialEq for crate::Path {
1705 fn eq(&self, other: &Self) -> bool {
1706 self.leading_colon == other.leading_colon && self.segments == other.segments
1707 }
1708}
1709#[cfg(any(feature = "derive", feature = "full"))]
1710#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1711impl Eq for crate::PathArguments {}
1712#[cfg(any(feature = "derive", feature = "full"))]
1713#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1714impl PartialEq for crate::PathArguments {
1715 fn eq(&self, other: &Self) -> bool {
1716 match (self, other) {
1717 (crate::PathArguments::None, crate::PathArguments::None) => true,
1718 (
1719 crate::PathArguments::AngleBracketed(self0),
1720 crate::PathArguments::AngleBracketed(other0),
1721 ) => self0 == other0,
1722 (
1723 crate::PathArguments::Parenthesized(self0),
1724 crate::PathArguments::Parenthesized(other0),
1725 ) => self0 == other0,
1726 _ => false,
1727 }
1728 }
1729}
1730#[cfg(any(feature = "derive", feature = "full"))]
1731#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1732impl Eq for crate::PathSegment {}
1733#[cfg(any(feature = "derive", feature = "full"))]
1734#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1735impl PartialEq for crate::PathSegment {
1736 fn eq(&self, other: &Self) -> bool {
1737 self.ident == other.ident && self.arguments == other.arguments
1738 }
1739}
1740#[cfg(any(feature = "derive", feature = "full"))]
1741#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1742impl Eq for crate::PointerMutability {}
1743#[cfg(any(feature = "derive", feature = "full"))]
1744#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1745impl PartialEq for crate::PointerMutability {
1746 fn eq(&self, other: &Self) -> bool {
1747 match (self, other) {
1748 (crate::PointerMutability::Const(_), crate::PointerMutability::Const(_)) => {
1749 true
1750 }
1751 (crate::PointerMutability::Mut(_), crate::PointerMutability::Mut(_)) => true,
1752 _ => false,
1753 }
1754 }
1755}
1756#[cfg(feature = "full")]
1757#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1758impl Eq for crate::PreciseCapture {}
1759#[cfg(feature = "full")]
1760#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1761impl PartialEq for crate::PreciseCapture {
1762 fn eq(&self, other: &Self) -> bool {
1763 self.params == other.params
1764 }
1765}
1766#[cfg(any(feature = "derive", feature = "full"))]
1767#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1768impl Eq for crate::PredicateLifetime {}
1769#[cfg(any(feature = "derive", feature = "full"))]
1770#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1771impl PartialEq for crate::PredicateLifetime {
1772 fn eq(&self, other: &Self) -> bool {
1773 self.attrs == other.attrs && self.lifetime == other.lifetime
1774 && self.bounds == other.bounds
1775 }
1776}
1777#[cfg(any(feature = "derive", feature = "full"))]
1778#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1779impl Eq for crate::PredicateType {}
1780#[cfg(any(feature = "derive", feature = "full"))]
1781#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1782impl PartialEq for crate::PredicateType {
1783 fn eq(&self, other: &Self) -> bool {
1784 self.attrs == other.attrs && self.lifetimes == other.lifetimes
1785 && self.bounded_ty == other.bounded_ty && self.bounds == other.bounds
1786 }
1787}
1788#[cfg(any(feature = "derive", feature = "full"))]
1789#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1790impl Eq for crate::QSelf {}
1791#[cfg(any(feature = "derive", feature = "full"))]
1792#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1793impl PartialEq for crate::QSelf {
1794 fn eq(&self, other: &Self) -> bool {
1795 self.ty == other.ty && self.position == other.position
1796 && self.as_token == other.as_token
1797 }
1798}
1799#[cfg(feature = "full")]
1800#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1801impl Eq for crate::RangeLimits {}
1802#[cfg(feature = "full")]
1803#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1804impl PartialEq for crate::RangeLimits {
1805 fn eq(&self, other: &Self) -> bool {
1806 match (self, other) {
1807 (crate::RangeLimits::HalfOpen(_), crate::RangeLimits::HalfOpen(_)) => true,
1808 (crate::RangeLimits::Closed(_), crate::RangeLimits::Closed(_)) => true,
1809 _ => false,
1810 }
1811 }
1812}
1813#[cfg(feature = "full")]
1814#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1815impl Eq for crate::Receiver {}
1816#[cfg(feature = "full")]
1817#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1818impl PartialEq for crate::Receiver {
1819 fn eq(&self, other: &Self) -> bool {
1820 self.attrs == other.attrs && self.mutability == other.mutability
1821 && self.kind == other.kind
1822 }
1823}
1824#[cfg(feature = "full")]
1825#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1826impl Eq for crate::ReceiverKind {}
1827#[cfg(feature = "full")]
1828#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1829impl PartialEq for crate::ReceiverKind {
1830 fn eq(&self, other: &Self) -> bool {
1831 match (self, other) {
1832 (crate::ReceiverKind::Value, crate::ReceiverKind::Value) => true,
1833 (
1834 crate::ReceiverKind::Reference(_, self1, self2),
1835 crate::ReceiverKind::Reference(_, other1, other2),
1836 ) => self1 == other1 && self2 == other2,
1837 (
1838 crate::ReceiverKind::Typed(_, self1),
1839 crate::ReceiverKind::Typed(_, other1),
1840 ) => self1 == other1,
1841 _ => false,
1842 }
1843 }
1844}
1845#[cfg(any(feature = "derive", feature = "full"))]
1846#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1847impl Eq for crate::ReturnType {}
1848#[cfg(any(feature = "derive", feature = "full"))]
1849#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1850impl PartialEq for crate::ReturnType {
1851 fn eq(&self, other: &Self) -> bool {
1852 match (self, other) {
1853 (crate::ReturnType::Default, crate::ReturnType::Default) => true,
1854 (crate::ReturnType::Type(_, self1), crate::ReturnType::Type(_, other1)) => {
1855 self1 == other1
1856 }
1857 _ => false,
1858 }
1859 }
1860}
1861#[cfg(feature = "full")]
1862#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1863impl Eq for crate::Safety {}
1864#[cfg(feature = "full")]
1865#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1866impl PartialEq for crate::Safety {
1867 fn eq(&self, other: &Self) -> bool {
1868 match (self, other) {
1869 (crate::Safety::Safe(_), crate::Safety::Safe(_)) => true,
1870 (crate::Safety::Unsafe(_), crate::Safety::Unsafe(_)) => true,
1871 (crate::Safety::Default, crate::Safety::Default) => true,
1872 _ => false,
1873 }
1874 }
1875}
1876#[cfg(feature = "full")]
1877#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1878impl Eq for crate::Signature {}
1879#[cfg(feature = "full")]
1880#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1881impl PartialEq for crate::Signature {
1882 fn eq(&self, other: &Self) -> bool {
1883 self.constness == other.constness && self.asyncness == other.asyncness
1884 && self.safety == other.safety && self.abi == other.abi
1885 && self.ident == other.ident && self.generics == other.generics
1886 && self.inputs == other.inputs && self.variadic == other.variadic
1887 && self.output == other.output
1888 }
1889}
1890#[cfg(feature = "full")]
1891#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1892impl Eq for crate::StaticMutability {}
1893#[cfg(feature = "full")]
1894#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1895impl PartialEq for crate::StaticMutability {
1896 fn eq(&self, other: &Self) -> bool {
1897 match (self, other) {
1898 (crate::StaticMutability::Mut(_), crate::StaticMutability::Mut(_)) => true,
1899 (crate::StaticMutability::None, crate::StaticMutability::None) => true,
1900 _ => false,
1901 }
1902 }
1903}
1904#[cfg(feature = "full")]
1905#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1906impl Eq for crate::Stmt {}
1907#[cfg(feature = "full")]
1908#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1909impl PartialEq for crate::Stmt {
1910 fn eq(&self, other: &Self) -> bool {
1911 match (self, other) {
1912 (crate::Stmt::Local(self0), crate::Stmt::Local(other0)) => self0 == other0,
1913 (crate::Stmt::Item(self0), crate::Stmt::Item(other0)) => self0 == other0,
1914 (crate::Stmt::Expr(self0, self1), crate::Stmt::Expr(other0, other1)) => {
1915 self0 == other0 && self1 == other1
1916 }
1917 (crate::Stmt::Macro(self0), crate::Stmt::Macro(other0)) => self0 == other0,
1918 _ => false,
1919 }
1920 }
1921}
1922#[cfg(feature = "full")]
1923#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1924impl Eq for crate::StmtMacro {}
1925#[cfg(feature = "full")]
1926#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1927impl PartialEq for crate::StmtMacro {
1928 fn eq(&self, other: &Self) -> bool {
1929 self.attrs == other.attrs && self.mac == other.mac
1930 && self.semi_token == other.semi_token
1931 }
1932}
1933#[cfg(any(feature = "derive", feature = "full"))]
1934#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1935impl Eq for crate::TraitBound {}
1936#[cfg(any(feature = "derive", feature = "full"))]
1937#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1938impl PartialEq for crate::TraitBound {
1939 fn eq(&self, other: &Self) -> bool {
1940 self.paren_token == other.paren_token && self.lifetimes == other.lifetimes
1941 && self.modifiers == other.modifiers && self.maybe == other.maybe
1942 && self.path == other.path
1943 }
1944}
1945#[cfg(any(feature = "derive", feature = "full"))]
1946#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1947impl Eq for crate::TraitBoundModifiers {}
1948#[cfg(any(feature = "derive", feature = "full"))]
1949#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1950impl PartialEq for crate::TraitBoundModifiers {
1951 fn eq(&self, _other: &Self) -> bool {
1952 true
1953 }
1954}
1955#[cfg(feature = "full")]
1956#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1957impl Eq for crate::TraitItem {}
1958#[cfg(feature = "full")]
1959#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1960impl PartialEq for crate::TraitItem {
1961 fn eq(&self, other: &Self) -> bool {
1962 match (self, other) {
1963 (crate::TraitItem::Const(self0), crate::TraitItem::Const(other0)) => {
1964 self0 == other0
1965 }
1966 (crate::TraitItem::Fn(self0), crate::TraitItem::Fn(other0)) => {
1967 self0 == other0
1968 }
1969 (crate::TraitItem::Type(self0), crate::TraitItem::Type(other0)) => {
1970 self0 == other0
1971 }
1972 (crate::TraitItem::Macro(self0), crate::TraitItem::Macro(other0)) => {
1973 self0 == other0
1974 }
1975 (crate::TraitItem::Verbatim(self0), crate::TraitItem::Verbatim(other0)) => {
1976 TokenStreamHelper(self0) == TokenStreamHelper(other0)
1977 }
1978 _ => false,
1979 }
1980 }
1981}
1982#[cfg(feature = "full")]
1983#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1984impl Eq for crate::TraitItemConst {}
1985#[cfg(feature = "full")]
1986#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1987impl PartialEq for crate::TraitItemConst {
1988 fn eq(&self, other: &Self) -> bool {
1989 self.attrs == other.attrs && self.modifiers == other.modifiers
1990 && self.ident == other.ident && self.generics == other.generics
1991 && self.ty == other.ty && self.default == other.default
1992 }
1993}
1994#[cfg(feature = "full")]
1995#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1996impl Eq for crate::TraitItemFn {}
1997#[cfg(feature = "full")]
1998#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1999impl PartialEq for crate::TraitItemFn {
2000 fn eq(&self, other: &Self) -> bool {
2001 self.attrs == other.attrs && self.modifiers == other.modifiers
2002 && self.sig == other.sig && self.default == other.default
2003 && self.semi_token == other.semi_token
2004 }
2005}
2006#[cfg(feature = "full")]
2007#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2008impl Eq for crate::TraitItemMacro {}
2009#[cfg(feature = "full")]
2010#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2011impl PartialEq for crate::TraitItemMacro {
2012 fn eq(&self, other: &Self) -> bool {
2013 self.attrs == other.attrs && self.mac == other.mac
2014 && self.semi_token == other.semi_token
2015 }
2016}
2017#[cfg(feature = "full")]
2018#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2019impl Eq for crate::TraitItemType {}
2020#[cfg(feature = "full")]
2021#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2022impl PartialEq for crate::TraitItemType {
2023 fn eq(&self, other: &Self) -> bool {
2024 self.attrs == other.attrs && self.modifiers == other.modifiers
2025 && self.ident == other.ident && self.generics == other.generics
2026 && self.colon_token == other.colon_token && self.bounds == other.bounds
2027 && self.default == other.default
2028 }
2029}
2030#[cfg(feature = "full")]
2031#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2032impl Eq for crate::TraitModifiers {}
2033#[cfg(feature = "full")]
2034#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2035impl PartialEq for crate::TraitModifiers {
2036 fn eq(&self, other: &Self) -> bool {
2037 self.auto_token == other.auto_token
2038 }
2039}
2040#[cfg(any(feature = "derive", feature = "full"))]
2041#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2042impl Eq for crate::Type {}
2043#[cfg(any(feature = "derive", feature = "full"))]
2044#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2045impl PartialEq for crate::Type {
2046 fn eq(&self, other: &Self) -> bool {
2047 match (self, other) {
2048 (crate::Type::Array(self0), crate::Type::Array(other0)) => self0 == other0,
2049 (crate::Type::FnPtr(self0), crate::Type::FnPtr(other0)) => self0 == other0,
2050 (crate::Type::Group(self0), crate::Type::Group(other0)) => self0 == other0,
2051 (crate::Type::ImplTrait(self0), crate::Type::ImplTrait(other0)) => {
2052 self0 == other0
2053 }
2054 (crate::Type::Infer(self0), crate::Type::Infer(other0)) => self0 == other0,
2055 (crate::Type::Macro(self0), crate::Type::Macro(other0)) => self0 == other0,
2056 (crate::Type::Never(self0), crate::Type::Never(other0)) => self0 == other0,
2057 (crate::Type::Paren(self0), crate::Type::Paren(other0)) => self0 == other0,
2058 (crate::Type::Path(self0), crate::Type::Path(other0)) => self0 == other0,
2059 (crate::Type::Ptr(self0), crate::Type::Ptr(other0)) => self0 == other0,
2060 (crate::Type::Reference(self0), crate::Type::Reference(other0)) => {
2061 self0 == other0
2062 }
2063 (crate::Type::Slice(self0), crate::Type::Slice(other0)) => self0 == other0,
2064 (crate::Type::TraitObject(self0), crate::Type::TraitObject(other0)) => {
2065 self0 == other0
2066 }
2067 (crate::Type::Tuple(self0), crate::Type::Tuple(other0)) => self0 == other0,
2068 (crate::Type::Verbatim(self0), crate::Type::Verbatim(other0)) => {
2069 TokenStreamHelper(self0) == TokenStreamHelper(other0)
2070 }
2071 _ => false,
2072 }
2073 }
2074}
2075#[cfg(any(feature = "derive", feature = "full"))]
2076#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2077impl Eq for crate::TypeArray {}
2078#[cfg(any(feature = "derive", feature = "full"))]
2079#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2080impl PartialEq for crate::TypeArray {
2081 fn eq(&self, other: &Self) -> bool {
2082 self.attrs == other.attrs && self.elem == other.elem && self.len == other.len
2083 }
2084}
2085#[cfg(any(feature = "derive", feature = "full"))]
2086#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2087impl Eq for crate::TypeFnPtr {}
2088#[cfg(any(feature = "derive", feature = "full"))]
2089#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2090impl PartialEq for crate::TypeFnPtr {
2091 fn eq(&self, other: &Self) -> bool {
2092 self.attrs == other.attrs && self.lifetimes == other.lifetimes
2093 && self.unsafety == other.unsafety && self.abi == other.abi
2094 && self.inputs == other.inputs && self.variadic == other.variadic
2095 && self.output == other.output
2096 }
2097}
2098#[cfg(any(feature = "derive", feature = "full"))]
2099#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2100impl Eq for crate::TypeGroup {}
2101#[cfg(any(feature = "derive", feature = "full"))]
2102#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2103impl PartialEq for crate::TypeGroup {
2104 fn eq(&self, other: &Self) -> bool {
2105 self.attrs == other.attrs && self.elem == other.elem
2106 }
2107}
2108#[cfg(any(feature = "derive", feature = "full"))]
2109#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2110impl Eq for crate::TypeImplTrait {}
2111#[cfg(any(feature = "derive", feature = "full"))]
2112#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2113impl PartialEq for crate::TypeImplTrait {
2114 fn eq(&self, other: &Self) -> bool {
2115 self.attrs == other.attrs && self.bounds == other.bounds
2116 }
2117}
2118#[cfg(any(feature = "derive", feature = "full"))]
2119#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2120impl Eq for crate::TypeInfer {}
2121#[cfg(any(feature = "derive", feature = "full"))]
2122#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2123impl PartialEq for crate::TypeInfer {
2124 fn eq(&self, other: &Self) -> bool {
2125 self.attrs == other.attrs
2126 }
2127}
2128#[cfg(any(feature = "derive", feature = "full"))]
2129#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2130impl Eq for crate::TypeMacro {}
2131#[cfg(any(feature = "derive", feature = "full"))]
2132#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2133impl PartialEq for crate::TypeMacro {
2134 fn eq(&self, other: &Self) -> bool {
2135 self.attrs == other.attrs && self.mac == other.mac
2136 }
2137}
2138#[cfg(feature = "full")]
2139#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2140impl Eq for crate::TypeModifiers {}
2141#[cfg(feature = "full")]
2142#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2143impl PartialEq for crate::TypeModifiers {
2144 fn eq(&self, other: &Self) -> bool {
2145 self.defaultness == other.defaultness
2146 }
2147}
2148#[cfg(any(feature = "derive", feature = "full"))]
2149#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2150impl Eq for crate::TypeNever {}
2151#[cfg(any(feature = "derive", feature = "full"))]
2152#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2153impl PartialEq for crate::TypeNever {
2154 fn eq(&self, other: &Self) -> bool {
2155 self.attrs == other.attrs
2156 }
2157}
2158#[cfg(any(feature = "derive", feature = "full"))]
2159#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2160impl Eq for crate::TypeParam {}
2161#[cfg(any(feature = "derive", feature = "full"))]
2162#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2163impl PartialEq for crate::TypeParam {
2164 fn eq(&self, other: &Self) -> bool {
2165 self.attrs == other.attrs && self.ident == other.ident
2166 && self.colon_token == other.colon_token && self.bounds == other.bounds
2167 && self.default == other.default
2168 }
2169}
2170#[cfg(any(feature = "derive", feature = "full"))]
2171#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2172impl Eq for crate::TypeParamBound {}
2173#[cfg(any(feature = "derive", feature = "full"))]
2174#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2175impl PartialEq for crate::TypeParamBound {
2176 fn eq(&self, other: &Self) -> bool {
2177 match (self, other) {
2178 (
2179 crate::TypeParamBound::Trait(self0),
2180 crate::TypeParamBound::Trait(other0),
2181 ) => self0 == other0,
2182 (
2183 crate::TypeParamBound::Lifetime(self0),
2184 crate::TypeParamBound::Lifetime(other0),
2185 ) => self0 == other0,
2186 #[cfg(feature = "full")]
2187 (
2188 crate::TypeParamBound::PreciseCapture(self0),
2189 crate::TypeParamBound::PreciseCapture(other0),
2190 ) => self0 == other0,
2191 (
2192 crate::TypeParamBound::Verbatim(self0),
2193 crate::TypeParamBound::Verbatim(other0),
2194 ) => TokenStreamHelper(self0) == TokenStreamHelper(other0),
2195 _ => false,
2196 }
2197 }
2198}
2199#[cfg(any(feature = "derive", feature = "full"))]
2200#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2201impl Eq for crate::TypeParen {}
2202#[cfg(any(feature = "derive", feature = "full"))]
2203#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2204impl PartialEq for crate::TypeParen {
2205 fn eq(&self, other: &Self) -> bool {
2206 self.attrs == other.attrs && self.elem == other.elem
2207 }
2208}
2209#[cfg(any(feature = "derive", feature = "full"))]
2210#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2211impl Eq for crate::TypePath {}
2212#[cfg(any(feature = "derive", feature = "full"))]
2213#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2214impl PartialEq for crate::TypePath {
2215 fn eq(&self, other: &Self) -> bool {
2216 self.attrs == other.attrs && self.qself == other.qself && self.path == other.path
2217 }
2218}
2219#[cfg(any(feature = "derive", feature = "full"))]
2220#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2221impl Eq for crate::TypePtr {}
2222#[cfg(any(feature = "derive", feature = "full"))]
2223#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2224impl PartialEq for crate::TypePtr {
2225 fn eq(&self, other: &Self) -> bool {
2226 self.attrs == other.attrs && self.mutability == other.mutability
2227 && self.elem == other.elem
2228 }
2229}
2230#[cfg(any(feature = "derive", feature = "full"))]
2231#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2232impl Eq for crate::TypeReference {}
2233#[cfg(any(feature = "derive", feature = "full"))]
2234#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2235impl PartialEq for crate::TypeReference {
2236 fn eq(&self, other: &Self) -> bool {
2237 self.attrs == other.attrs && self.lifetime == other.lifetime
2238 && self.mutability == other.mutability && self.elem == other.elem
2239 }
2240}
2241#[cfg(any(feature = "derive", feature = "full"))]
2242#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2243impl Eq for crate::TypeSlice {}
2244#[cfg(any(feature = "derive", feature = "full"))]
2245#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2246impl PartialEq for crate::TypeSlice {
2247 fn eq(&self, other: &Self) -> bool {
2248 self.attrs == other.attrs && self.elem == other.elem
2249 }
2250}
2251#[cfg(any(feature = "derive", feature = "full"))]
2252#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2253impl Eq for crate::TypeTraitObject {}
2254#[cfg(any(feature = "derive", feature = "full"))]
2255#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2256impl PartialEq for crate::TypeTraitObject {
2257 fn eq(&self, other: &Self) -> bool {
2258 self.attrs == other.attrs && self.dyn_token == other.dyn_token
2259 && self.bounds == other.bounds
2260 }
2261}
2262#[cfg(any(feature = "derive", feature = "full"))]
2263#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2264impl Eq for crate::TypeTuple {}
2265#[cfg(any(feature = "derive", feature = "full"))]
2266#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2267impl PartialEq for crate::TypeTuple {
2268 fn eq(&self, other: &Self) -> bool {
2269 self.attrs == other.attrs && self.elems == other.elems
2270 }
2271}
2272#[cfg(any(feature = "derive", feature = "full"))]
2273#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2274impl Eq for crate::UnOp {}
2275#[cfg(any(feature = "derive", feature = "full"))]
2276#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2277impl PartialEq for crate::UnOp {
2278 fn eq(&self, other: &Self) -> bool {
2279 match (self, other) {
2280 (crate::UnOp::Deref(_), crate::UnOp::Deref(_)) => true,
2281 (crate::UnOp::Not(_), crate::UnOp::Not(_)) => true,
2282 (crate::UnOp::Neg(_), crate::UnOp::Neg(_)) => true,
2283 _ => false,
2284 }
2285 }
2286}
2287#[cfg(feature = "full")]
2288#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2289impl Eq for crate::UseGlob {}
2290#[cfg(feature = "full")]
2291#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2292impl PartialEq for crate::UseGlob {
2293 fn eq(&self, _other: &Self) -> bool {
2294 true
2295 }
2296}
2297#[cfg(feature = "full")]
2298#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2299impl Eq for crate::UseGroup {}
2300#[cfg(feature = "full")]
2301#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2302impl PartialEq for crate::UseGroup {
2303 fn eq(&self, other: &Self) -> bool {
2304 self.items == other.items
2305 }
2306}
2307#[cfg(feature = "full")]
2308#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2309impl Eq for crate::UseName {}
2310#[cfg(feature = "full")]
2311#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2312impl PartialEq for crate::UseName {
2313 fn eq(&self, other: &Self) -> bool {
2314 self.ident == other.ident
2315 }
2316}
2317#[cfg(feature = "full")]
2318#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2319impl Eq for crate::UsePath {}
2320#[cfg(feature = "full")]
2321#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2322impl PartialEq for crate::UsePath {
2323 fn eq(&self, other: &Self) -> bool {
2324 self.ident == other.ident && self.tree == other.tree
2325 }
2326}
2327#[cfg(feature = "full")]
2328#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2329impl Eq for crate::UseRename {}
2330#[cfg(feature = "full")]
2331#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2332impl PartialEq for crate::UseRename {
2333 fn eq(&self, other: &Self) -> bool {
2334 self.ident == other.ident && self.rename == other.rename
2335 }
2336}
2337#[cfg(feature = "full")]
2338#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2339impl Eq for crate::UseTree {}
2340#[cfg(feature = "full")]
2341#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2342impl PartialEq for crate::UseTree {
2343 fn eq(&self, other: &Self) -> bool {
2344 match (self, other) {
2345 (crate::UseTree::Path(self0), crate::UseTree::Path(other0)) => {
2346 self0 == other0
2347 }
2348 (crate::UseTree::Name(self0), crate::UseTree::Name(other0)) => {
2349 self0 == other0
2350 }
2351 (crate::UseTree::Rename(self0), crate::UseTree::Rename(other0)) => {
2352 self0 == other0
2353 }
2354 (crate::UseTree::Glob(self0), crate::UseTree::Glob(other0)) => {
2355 self0 == other0
2356 }
2357 (crate::UseTree::Group(self0), crate::UseTree::Group(other0)) => {
2358 self0 == other0
2359 }
2360 _ => false,
2361 }
2362 }
2363}
2364#[cfg(feature = "full")]
2365#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2366impl Eq for crate::Variadic {}
2367#[cfg(feature = "full")]
2368#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2369impl PartialEq for crate::Variadic {
2370 fn eq(&self, other: &Self) -> bool {
2371 self.attrs == other.attrs && self.pat == other.pat && self.comma == other.comma
2372 }
2373}
2374#[cfg(any(feature = "derive", feature = "full"))]
2375#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2376impl Eq for crate::Variant {}
2377#[cfg(any(feature = "derive", feature = "full"))]
2378#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2379impl PartialEq for crate::Variant {
2380 fn eq(&self, other: &Self) -> bool {
2381 self.attrs == other.attrs && self.ident == other.ident
2382 && self.fields == other.fields && self.discriminant == other.discriminant
2383 }
2384}
2385#[cfg(any(feature = "derive", feature = "full"))]
2386#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2387impl Eq for crate::VisRestricted {}
2388#[cfg(any(feature = "derive", feature = "full"))]
2389#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2390impl PartialEq for crate::VisRestricted {
2391 fn eq(&self, other: &Self) -> bool {
2392 self.in_token == other.in_token && self.path == other.path
2393 }
2394}
2395#[cfg(any(feature = "derive", feature = "full"))]
2396#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2397impl Eq for crate::Visibility {}
2398#[cfg(any(feature = "derive", feature = "full"))]
2399#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2400impl PartialEq for crate::Visibility {
2401 fn eq(&self, other: &Self) -> bool {
2402 match (self, other) {
2403 (crate::Visibility::Public(_), crate::Visibility::Public(_)) => true,
2404 (
2405 crate::Visibility::Restricted(self0),
2406 crate::Visibility::Restricted(other0),
2407 ) => self0 == other0,
2408 (crate::Visibility::Inherited, crate::Visibility::Inherited) => true,
2409 _ => false,
2410 }
2411 }
2412}
2413#[cfg(any(feature = "derive", feature = "full"))]
2414#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2415impl Eq for crate::WhereClause {}
2416#[cfg(any(feature = "derive", feature = "full"))]
2417#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2418impl PartialEq for crate::WhereClause {
2419 fn eq(&self, other: &Self) -> bool {
2420 self.predicates == other.predicates
2421 }
2422}
2423#[cfg(feature = "full")]
2424#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2425impl Eq for crate::WhereClausePlacement {}
2426#[cfg(feature = "full")]
2427#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2428impl PartialEq for crate::WhereClausePlacement {
2429 fn eq(&self, other: &Self) -> bool {
2430 match (self, other) {
2431 (crate::WhereClausePlacement::Early, crate::WhereClausePlacement::Early) => {
2432 true
2433 }
2434 (crate::WhereClausePlacement::Late, crate::WhereClausePlacement::Late) => {
2435 true
2436 }
2437 _ => false,
2438 }
2439 }
2440}
2441#[cfg(any(feature = "derive", feature = "full"))]
2442#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2443impl Eq for crate::WherePredicate {}
2444#[cfg(any(feature = "derive", feature = "full"))]
2445#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2446impl PartialEq for crate::WherePredicate {
2447 fn eq(&self, other: &Self) -> bool {
2448 match (self, other) {
2449 (
2450 crate::WherePredicate::Lifetime(self0),
2451 crate::WherePredicate::Lifetime(other0),
2452 ) => self0 == other0,
2453 (crate::WherePredicate::Type(self0), crate::WherePredicate::Type(other0)) => {
2454 self0 == other0
2455 }
2456 _ => false,
2457 }
2458 }
2459}