CoCalc -- eq.rs

GitHub Repository: torvalds/linux
Path: blob/master/rust/syn/gen/eq.rs
³⁸³¹⁶ views
1
// SPDX-License-Identifier: Apache-2.0 OR MIT
2

3
// This file is @generated by syn-internal-codegen.
4
// It is not intended for manual editing.
5

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

2310
Product

Resources

Company
