1#[cfg(any(feature = "derive", feature = "full"))]
5use crate::tt::TokenStreamHelper;
6#[cfg(feature = "extra-traits")]
7use alloc::string::ToString;
8#[cfg(any(feature = "derive", feature = "full"))]
9#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
10impl Eq for crate::Abi {}
11#[cfg(any(feature = "derive", feature = "full"))]
12#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
13impl PartialEq for crate::Abi {
14 fn eq(&self, other: &Self) -> bool {
15 self.name == other.name
16 }
17}
18#[cfg(any(feature = "derive", feature = "full"))]
19#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
20impl Eq for crate::AngleBracketedGenericArguments {}
21#[cfg(any(feature = "derive", feature = "full"))]
22#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
23impl PartialEq for crate::AngleBracketedGenericArguments {
24 fn eq(&self, other: &Self) -> bool {
25 self.colon2_token == other.colon2_token && self.args == other.args
26 }
27}
28#[cfg(feature = "full")]
29#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
30impl Eq for crate::Arm {}
31#[cfg(feature = "full")]
32#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
33impl PartialEq for crate::Arm {
34 fn eq(&self, other: &Self) -> bool {
35 self.attrs == other.attrs && self.pat == other.pat && self.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")))]
41impl Eq for crate::AssocConst {}
42#[cfg(any(feature = "derive", feature = "full"))]
43#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
44impl PartialEq for crate::AssocConst {
45 fn eq(&self, other: &Self) -> bool {
46 self.ident == other.ident && self.generics == other.generics
47 && self.value == other.value
48 }
49}
50#[cfg(any(feature = "derive", feature = "full"))]
51#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
52impl Eq for crate::AssocType {}
53#[cfg(any(feature = "derive", feature = "full"))]
54#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
55impl PartialEq for crate::AssocType {
56 fn eq(&self, other: &Self) -> bool {
57 self.ident == other.ident && self.generics == other.generics
58 && self.ty == other.ty
59 }
60}
61#[cfg(any(feature = "derive", feature = "full"))]
62#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
63impl Eq for crate::AttrStyle {}
64#[cfg(any(feature = "derive", feature = "full"))]
65#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
66impl PartialEq for crate::AttrStyle {
67 fn eq(&self, other: &Self) -> bool {
68 match (self, other) {
69 (crate::AttrStyle::Outer, crate::AttrStyle::Outer) => true,
70 (crate::AttrStyle::Inner(_), crate::AttrStyle::Inner(_)) => true,
71 _ => false,
72 }
73 }
74}
75#[cfg(any(feature = "derive", feature = "full"))]
76#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
77impl Eq for crate::Attribute {}
78#[cfg(any(feature = "derive", feature = "full"))]
79#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
80impl PartialEq for crate::Attribute {
81 fn eq(&self, other: &Self) -> bool {
82 self.style == other.style && self.meta == other.meta
83 }
84}
85#[cfg(any(feature = "derive", feature = "full"))]
86#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
87impl Eq for crate::BareFnArg {}
88#[cfg(any(feature = "derive", feature = "full"))]
89#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
90impl 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")))]
97impl Eq for crate::BareVariadic {}
98#[cfg(any(feature = "derive", feature = "full"))]
99#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
100impl 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")))]
107impl Eq for crate::BinOp {}
108#[cfg(any(feature = "derive", feature = "full"))]
109#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
110impl 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")))]
147impl Eq for crate::Block {}
148#[cfg(feature = "full")]
149#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
150impl 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")))]
157impl Eq for crate::BoundLifetimes {}
158#[cfg(any(feature = "derive", feature = "full"))]
159#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
160impl 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")))]
167impl Eq for crate::CapturedParam {}
168#[cfg(feature = "full")]
169#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
170impl 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")))]
186impl Eq for crate::ConstParam {}
187#[cfg(any(feature = "derive", feature = "full"))]
188#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
189impl 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")))]
197impl Eq for crate::Constraint {}
198#[cfg(any(feature = "derive", feature = "full"))]
199#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
200impl 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")))]
208impl Eq for crate::Data {}
209#[cfg(feature = "derive")]
210#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
211impl 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")))]
223impl Eq for crate::DataEnum {}
224#[cfg(feature = "derive")]
225#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
226impl 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")))]
233impl Eq for crate::DataStruct {}
234#[cfg(feature = "derive")]
235#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
236impl 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")))]
243impl Eq for crate::DataUnion {}
244#[cfg(feature = "derive")]
245#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
246impl 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")))]
253impl Eq for crate::DeriveInput {}
254#[cfg(feature = "derive")]
255#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
256impl 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")))]
264impl Eq for crate::Expr {}
265#[cfg(any(feature = "derive", feature = "full"))]
266#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
267impl 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")))]
356impl Eq for crate::ExprArray {}
357#[cfg(feature = "full")]
358#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
359impl 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")))]
366impl Eq for crate::ExprAssign {}
367#[cfg(feature = "full")]
368#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
369impl 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")))]
376impl Eq for crate::ExprAsync {}
377#[cfg(feature = "full")]
378#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
379impl 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")))]
387impl Eq for crate::ExprAwait {}
388#[cfg(feature = "full")]
389#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
390impl 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")))]
397impl Eq for crate::ExprBinary {}
398#[cfg(any(feature = "derive", feature = "full"))]
399#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
400impl 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")))]
408impl Eq for crate::ExprBlock {}
409#[cfg(feature = "full")]
410#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
411impl 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")))]
419impl Eq for crate::ExprBreak {}
420#[cfg(feature = "full")]
421#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
422impl 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")))]
429impl Eq for crate::ExprCall {}
430#[cfg(any(feature = "derive", feature = "full"))]
431#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
432impl 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")))]
439impl Eq for crate::ExprCast {}
440#[cfg(any(feature = "derive", feature = "full"))]
441#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
442impl 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")))]
449impl Eq for crate::ExprClosure {}
450#[cfg(feature = "full")]
451#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
452impl 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")))]
463impl Eq for crate::ExprConst {}
464#[cfg(feature = "full")]
465#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
466impl 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")))]
473impl Eq for crate::ExprContinue {}
474#[cfg(feature = "full")]
475#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
476impl 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")))]
483impl Eq for crate::ExprField {}
484#[cfg(any(feature = "derive", feature = "full"))]
485#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
486impl 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")))]
494impl Eq for crate::ExprForLoop {}
495#[cfg(feature = "full")]
496#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
497impl 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")))]
505impl Eq for crate::ExprGroup {}
506#[cfg(any(feature = "derive", feature = "full"))]
507#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
508impl 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")))]
515impl Eq for crate::ExprIf {}
516#[cfg(feature = "full")]
517#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
518impl 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")))]
527impl Eq for crate::ExprIndex {}
528#[cfg(any(feature = "derive", feature = "full"))]
529#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
530impl 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")))]
537impl Eq for crate::ExprInfer {}
538#[cfg(feature = "full")]
539#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
540impl 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")))]
547impl Eq for crate::ExprLet {}
548#[cfg(feature = "full")]
549#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
550impl 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")))]
557impl Eq for crate::ExprLit {}
558#[cfg(any(feature = "derive", feature = "full"))]
559#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
560impl 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")))]
567impl Eq for crate::ExprLoop {}
568#[cfg(feature = "full")]
569#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
570impl 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")))]
577impl Eq for crate::ExprMacro {}
578#[cfg(any(feature = "derive", feature = "full"))]
579#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
580impl 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")))]
587impl Eq for crate::ExprMatch {}
588#[cfg(feature = "full")]
589#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
590impl 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")))]
597impl Eq for crate::ExprMethodCall {}
598#[cfg(any(feature = "derive", feature = "full"))]
599#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
600impl 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")))]
609impl Eq for crate::ExprParen {}
610#[cfg(any(feature = "derive", feature = "full"))]
611#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
612impl 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")))]
619impl Eq for crate::ExprPath {}
620#[cfg(any(feature = "derive", feature = "full"))]
621#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
622impl 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")))]
629impl Eq for crate::ExprRange {}
630#[cfg(feature = "full")]
631#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
632impl 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")))]
640impl Eq for crate::ExprRawAddr {}
641#[cfg(feature = "full")]
642#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
643impl 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")))]
651impl Eq for crate::ExprReference {}
652#[cfg(any(feature = "derive", feature = "full"))]
653#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
654impl 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")))]
662impl Eq for crate::ExprRepeat {}
663#[cfg(feature = "full")]
664#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
665impl 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")))]
672impl Eq for crate::ExprReturn {}
673#[cfg(feature = "full")]
674#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
675impl 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")))]
682impl Eq for crate::ExprStruct {}
683#[cfg(any(feature = "derive", feature = "full"))]
684#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
685impl 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")))]
694impl Eq for crate::ExprTry {}
695#[cfg(feature = "full")]
696#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
697impl 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")))]
704impl Eq for crate::ExprTryBlock {}
705#[cfg(feature = "full")]
706#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
707impl 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")))]
714impl Eq for crate::ExprTuple {}
715#[cfg(any(feature = "derive", feature = "full"))]
716#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
717impl 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")))]
724impl Eq for crate::ExprUnary {}
725#[cfg(any(feature = "derive", feature = "full"))]
726#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
727impl 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")))]
734impl Eq for crate::ExprUnsafe {}
735#[cfg(feature = "full")]
736#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
737impl 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")))]
744impl Eq for crate::ExprWhile {}
745#[cfg(feature = "full")]
746#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
747impl 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")))]
755impl Eq for crate::ExprYield {}
756#[cfg(feature = "full")]
757#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
758impl 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")))]
765impl Eq for crate::Field {}
766#[cfg(any(feature = "derive", feature = "full"))]
767#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
768impl 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")))]
777impl Eq for crate::FieldMutability {}
778#[cfg(any(feature = "derive", feature = "full"))]
779#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
780impl 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")))]
789impl Eq for crate::FieldPat {}
790#[cfg(feature = "full")]
791#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
792impl 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")))]
800impl Eq for crate::FieldValue {}
801#[cfg(any(feature = "derive", feature = "full"))]
802#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
803impl 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")))]
811impl Eq for crate::Fields {}
812#[cfg(any(feature = "derive", feature = "full"))]
813#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
814impl 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")))]
830impl Eq for crate::FieldsNamed {}
831#[cfg(any(feature = "derive", feature = "full"))]
832#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
833impl 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")))]
840impl Eq for crate::FieldsUnnamed {}
841#[cfg(any(feature = "derive", feature = "full"))]
842#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
843impl 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")))]
850impl Eq for crate::File {}
851#[cfg(feature = "full")]
852#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
853impl 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")))]
861impl Eq for crate::FnArg {}
862#[cfg(feature = "full")]
863#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
864impl 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")))]
877impl Eq for crate::ForeignItem {}
878#[cfg(feature = "full")]
879#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
880impl 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")))]
905impl Eq for crate::ForeignItemFn {}
906#[cfg(feature = "full")]
907#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
908impl 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")))]
915impl Eq for crate::ForeignItemMacro {}
916#[cfg(feature = "full")]
917#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
918impl 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")))]
926impl Eq for crate::ForeignItemStatic {}
927#[cfg(feature = "full")]
928#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
929impl 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")))]
938impl Eq for crate::ForeignItemType {}
939#[cfg(feature = "full")]
940#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
941impl 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")))]
949impl Eq for crate::GenericArgument {}
950#[cfg(any(feature = "derive", feature = "full"))]
951#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
952impl 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")))]
985impl Eq for crate::GenericParam {}
986#[cfg(any(feature = "derive", feature = "full"))]
987#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
988impl 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")))]
1007impl Eq for crate::Generics {}
1008#[cfg(any(feature = "derive", feature = "full"))]
1009#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1010impl 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")))]
1018impl Eq for crate::ImplItem {}
1019#[cfg(feature = "full")]
1020#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1021impl 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")))]
1043impl Eq for crate::ImplItemConst {}
1044#[cfg(feature = "full")]
1045#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1046impl 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")))]
1056impl Eq for crate::ImplItemFn {}
1057#[cfg(feature = "full")]
1058#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1059impl 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")))]
1068impl Eq for crate::ImplItemMacro {}
1069#[cfg(feature = "full")]
1070#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1071impl 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")))]
1079impl Eq for crate::ImplItemType {}
1080#[cfg(feature = "full")]
1081#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1082impl 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")))]
1091impl Eq for crate::ImplRestriction {}
1092#[cfg(feature = "full")]
1093#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1094impl 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")))]
1101impl Eq for crate::Item {}
1102#[cfg(feature = "full")]
1103#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1104impl 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")))]
1137impl Eq for crate::ItemConst {}
1138#[cfg(feature = "full")]
1139#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1140impl 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")))]
1149impl Eq for crate::ItemEnum {}
1150#[cfg(feature = "full")]
1151#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1152impl 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")))]
1160impl Eq for crate::ItemExternCrate {}
1161#[cfg(feature = "full")]
1162#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1163impl 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")))]
1171impl Eq for crate::ItemFn {}
1172#[cfg(feature = "full")]
1173#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1174impl 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")))]
1182impl Eq for crate::ItemForeignMod {}
1183#[cfg(feature = "full")]
1184#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1185impl 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")))]
1193impl Eq for crate::ItemImpl {}
1194#[cfg(feature = "full")]
1195#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1196impl 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")))]
1206impl Eq for crate::ItemMacro {}
1207#[cfg(feature = "full")]
1208#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1209impl 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")))]
1217impl Eq for crate::ItemMod {}
1218#[cfg(feature = "full")]
1219#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1220impl 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")))]
1229impl Eq for crate::ItemStatic {}
1230#[cfg(feature = "full")]
1231#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1232impl 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")))]
1241impl Eq for crate::ItemStruct {}
1242#[cfg(feature = "full")]
1243#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1244impl 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")))]
1253impl Eq for crate::ItemTrait {}
1254#[cfg(feature = "full")]
1255#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1256impl 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")))]
1267impl Eq for crate::ItemTraitAlias {}
1268#[cfg(feature = "full")]
1269#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1270impl 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")))]
1278impl Eq for crate::ItemType {}
1279#[cfg(feature = "full")]
1280#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1281impl 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")))]
1289impl Eq for crate::ItemUnion {}
1290#[cfg(feature = "full")]
1291#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1292impl 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")))]
1300impl Eq for crate::ItemUse {}
1301#[cfg(feature = "full")]
1302#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1303impl 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")))]
1311impl Eq for crate::Label {}
1312#[cfg(feature = "full")]
1313#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1314impl 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")))]
1321impl Eq for crate::LifetimeParam {}
1322#[cfg(any(feature = "derive", feature = "full"))]
1323#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1324impl 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")))]
1331impl Eq for crate::Lit {}
1332#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1333impl 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")))]
1352impl Eq for crate::LitBool {}
1353#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1354impl 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")))]
1360impl Eq for crate::LitByte {}
1361#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1362impl Eq for crate::LitByteStr {}
1363#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1364impl Eq for crate::LitCStr {}
1365#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1366impl Eq for crate::LitChar {}
1367#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1368impl Eq for crate::LitFloat {}
1369#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1370impl Eq for crate::LitInt {}
1371#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1372impl Eq for crate::LitStr {}
1373#[cfg(feature = "full")]
1374#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1375impl Eq for crate::Local {}
1376#[cfg(feature = "full")]
1377#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1378impl 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")))]
1385impl Eq for crate::LocalInit {}
1386#[cfg(feature = "full")]
1387#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1388impl 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")))]
1395impl Eq for crate::Macro {}
1396#[cfg(any(feature = "derive", feature = "full"))]
1397#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1398impl 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")))]
1406impl Eq for crate::MacroDelimiter {}
1407#[cfg(any(feature = "derive", feature = "full"))]
1408#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1409impl 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")))]
1423impl Eq for crate::Meta {}
1424#[cfg(any(feature = "derive", feature = "full"))]
1425#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1426impl 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")))]
1440impl Eq for crate::MetaList {}
1441#[cfg(any(feature = "derive", feature = "full"))]
1442#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1443impl 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")))]
1451impl Eq for crate::MetaNameValue {}
1452#[cfg(any(feature = "derive", feature = "full"))]
1453#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1454impl 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")))]
1461impl Eq for crate::ParenthesizedGenericArguments {}
1462#[cfg(any(feature = "derive", feature = "full"))]
1463#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1464impl 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")))]
1471impl Eq for crate::Pat {}
1472#[cfg(feature = "full")]
1473#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1474impl 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")))]
1506impl Eq for crate::PatIdent {}
1507#[cfg(feature = "full")]
1508#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1509impl 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")))]
1518impl Eq for crate::PatOr {}
1519#[cfg(feature = "full")]
1520#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1521impl 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")))]
1529impl Eq for crate::PatParen {}
1530#[cfg(feature = "full")]
1531#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1532impl 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")))]
1539impl Eq for crate::PatReference {}
1540#[cfg(feature = "full")]
1541#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1542impl 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")))]
1550impl Eq for crate::PatRest {}
1551#[cfg(feature = "full")]
1552#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1553impl 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")))]
1560impl Eq for crate::PatSlice {}
1561#[cfg(feature = "full")]
1562#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1563impl 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")))]
1570impl Eq for crate::PatStruct {}
1571#[cfg(feature = "full")]
1572#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1573impl 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")))]
1581impl Eq for crate::PatTuple {}
1582#[cfg(feature = "full")]
1583#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1584impl 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")))]
1591impl Eq for crate::PatTupleStruct {}
1592#[cfg(feature = "full")]
1593#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1594impl 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")))]
1602impl Eq for crate::PatType {}
1603#[cfg(feature = "full")]
1604#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1605impl 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")))]
1612impl Eq for crate::PatWild {}
1613#[cfg(feature = "full")]
1614#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1615impl 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")))]
1622impl Eq for crate::Path {}
1623#[cfg(any(feature = "derive", feature = "full"))]
1624#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1625impl 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")))]
1632impl Eq for crate::PathArguments {}
1633#[cfg(any(feature = "derive", feature = "full"))]
1634#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1635impl 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")))]
1653impl Eq for crate::PathSegment {}
1654#[cfg(any(feature = "derive", feature = "full"))]
1655#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1656impl 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")))]
1663impl Eq for crate::PointerMutability {}
1664#[cfg(feature = "full")]
1665#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1666impl 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")))]
1679impl Eq for crate::PreciseCapture {}
1680#[cfg(feature = "full")]
1681#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1682impl 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")))]
1689impl Eq for crate::PredicateLifetime {}
1690#[cfg(any(feature = "derive", feature = "full"))]
1691#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1692impl 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")))]
1699impl Eq for crate::PredicateType {}
1700#[cfg(any(feature = "derive", feature = "full"))]
1701#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1702impl 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")))]
1710impl Eq for crate::QSelf {}
1711#[cfg(any(feature = "derive", feature = "full"))]
1712#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1713impl 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")))]
1721impl Eq for crate::RangeLimits {}
1722#[cfg(feature = "full")]
1723#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1724impl 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")))]
1735impl Eq for crate::Receiver {}
1736#[cfg(feature = "full")]
1737#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1738impl 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")))]
1747impl Eq for crate::ReturnType {}
1748#[cfg(any(feature = "derive", feature = "full"))]
1749#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1750impl 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")))]
1763impl Eq for crate::Signature {}
1764#[cfg(feature = "full")]
1765#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1766impl 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")))]
1777impl Eq for crate::StaticMutability {}
1778#[cfg(feature = "full")]
1779#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1780impl 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")))]
1791impl Eq for crate::Stmt {}
1792#[cfg(feature = "full")]
1793#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1794impl 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")))]
1809impl Eq for crate::StmtMacro {}
1810#[cfg(feature = "full")]
1811#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1812impl 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")))]
1820impl Eq for crate::TraitBound {}
1821#[cfg(any(feature = "derive", feature = "full"))]
1822#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1823impl 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")))]
1831impl Eq for crate::TraitBoundModifier {}
1832#[cfg(any(feature = "derive", feature = "full"))]
1833#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1834impl 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")))]
1848impl Eq for crate::TraitItem {}
1849#[cfg(feature = "full")]
1850#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1851impl 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")))]
1875impl Eq for crate::TraitItemConst {}
1876#[cfg(feature = "full")]
1877#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1878impl 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")))]
1887impl Eq for crate::TraitItemFn {}
1888#[cfg(feature = "full")]
1889#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1890impl 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")))]
1898impl Eq for crate::TraitItemMacro {}
1899#[cfg(feature = "full")]
1900#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1901impl 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")))]
1909impl Eq for crate::TraitItemType {}
1910#[cfg(feature = "full")]
1911#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1912impl 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")))]
1921impl Eq for crate::Type {}
1922#[cfg(any(feature = "derive", feature = "full"))]
1923#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1924impl 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")))]
1956impl Eq for crate::TypeArray {}
1957#[cfg(any(feature = "derive", feature = "full"))]
1958#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1959impl 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")))]
1966impl Eq for crate::TypeBareFn {}
1967#[cfg(any(feature = "derive", feature = "full"))]
1968#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1969impl 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")))]
1978impl Eq for crate::TypeGroup {}
1979#[cfg(any(feature = "derive", feature = "full"))]
1980#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1981impl 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")))]
1988impl Eq for crate::TypeImplTrait {}
1989#[cfg(any(feature = "derive", feature = "full"))]
1990#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
1991impl 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")))]
1998impl Eq for crate::TypeInfer {}
1999#[cfg(any(feature = "derive", feature = "full"))]
2000#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2001impl 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")))]
2008impl Eq for crate::TypeMacro {}
2009#[cfg(any(feature = "derive", feature = "full"))]
2010#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2011impl 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")))]
2018impl Eq for crate::TypeNever {}
2019#[cfg(any(feature = "derive", feature = "full"))]
2020#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2021impl 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")))]
2028impl Eq for crate::TypeParam {}
2029#[cfg(any(feature = "derive", feature = "full"))]
2030#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2031impl 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")))]
2040impl Eq for crate::TypeParamBound {}
2041#[cfg(any(feature = "derive", feature = "full"))]
2042#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2043impl 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")))]
2069impl Eq for crate::TypeParen {}
2070#[cfg(any(feature = "derive", feature = "full"))]
2071#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2072impl 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")))]
2079impl Eq for crate::TypePath {}
2080#[cfg(any(feature = "derive", feature = "full"))]
2081#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2082impl 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")))]
2089impl Eq for crate::TypePtr {}
2090#[cfg(any(feature = "derive", feature = "full"))]
2091#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2092impl 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")))]
2100impl Eq for crate::TypeReference {}
2101#[cfg(any(feature = "derive", feature = "full"))]
2102#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2103impl 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")))]
2111impl Eq for crate::TypeSlice {}
2112#[cfg(any(feature = "derive", feature = "full"))]
2113#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2114impl 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")))]
2121impl Eq for crate::TypeTraitObject {}
2122#[cfg(any(feature = "derive", feature = "full"))]
2123#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2124impl 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")))]
2131impl Eq for crate::TypeTuple {}
2132#[cfg(any(feature = "derive", feature = "full"))]
2133#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2134impl 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")))]
2141impl Eq for crate::UnOp {}
2142#[cfg(any(feature = "derive", feature = "full"))]
2143#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2144impl 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")))]
2156impl Eq for crate::UseGlob {}
2157#[cfg(feature = "full")]
2158#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2159impl 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")))]
2166impl Eq for crate::UseGroup {}
2167#[cfg(feature = "full")]
2168#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2169impl 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")))]
2176impl Eq for crate::UseName {}
2177#[cfg(feature = "full")]
2178#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2179impl 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")))]
2186impl Eq for crate::UsePath {}
2187#[cfg(feature = "full")]
2188#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2189impl 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")))]
2196impl Eq for crate::UseRename {}
2197#[cfg(feature = "full")]
2198#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2199impl 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")))]
2206impl Eq for crate::UseTree {}
2207#[cfg(feature = "full")]
2208#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2209impl 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")))]
2233impl Eq for crate::Variadic {}
2234#[cfg(feature = "full")]
2235#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2236impl 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")))]
2243impl Eq for crate::Variant {}
2244#[cfg(any(feature = "derive", feature = "full"))]
2245#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2246impl 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")))]
2254impl Eq for crate::VisRestricted {}
2255#[cfg(any(feature = "derive", feature = "full"))]
2256#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2257impl 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")))]
2264impl Eq for crate::Visibility {}
2265#[cfg(any(feature = "derive", feature = "full"))]
2266#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2267impl 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")))]
2282impl Eq for crate::WhereClause {}
2283#[cfg(any(feature = "derive", feature = "full"))]
2284#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2285impl 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")))]
2292impl Eq for crate::WherePredicate {}
2293#[cfg(any(feature = "derive", feature = "full"))]
2294#[cfg_attr(docsrs, doc(cfg(feature = "extra-traits")))]
2295impl 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}