Debian Codegraph @

rust/syn/gen/eq.rs

raw
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 }