1 // This file is @generated by syn-internal-codegen.
2 // It is not intended for manual editing.
3 
4 #[cfg(any(feature = "derive", feature = "full"))]
5 use crate::tt::TokenStreamHelper;
6 use crate::*;
7 use std::hash::{Hash, Hasher};
8 #[cfg(any(feature = "derive", feature = "full"))]
9 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
10 impl Hash for Abi {
hashnull11     fn hash<H>(&self, state: &mut H)
12     where
13         H: Hasher,
14     {
15         self.name.hash(state);
16     }
17 }
18 #[cfg(any(feature = "derive", feature = "full"))]
19 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
20 impl Hash for AngleBracketedGenericArguments {
hashnull21     fn hash<H>(&self, state: &mut H)
22     where
23         H: Hasher,
24     {
25         self.colon2_token.hash(state);
26         self.args.hash(state);
27     }
28 }
29 #[cfg(feature = "full")]
30 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
31 impl Hash for Arm {
hashnull32     fn hash<H>(&self, state: &mut H)
33     where
34         H: Hasher,
35     {
36         self.attrs.hash(state);
37         self.pat.hash(state);
38         self.guard.hash(state);
39         self.body.hash(state);
40         self.comma.hash(state);
41     }
42 }
43 #[cfg(any(feature = "derive", feature = "full"))]
44 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
45 impl Hash for AssocConst {
hashnull46     fn hash<H>(&self, state: &mut H)
47     where
48         H: Hasher,
49     {
50         self.ident.hash(state);
51         self.generics.hash(state);
52         self.value.hash(state);
53     }
54 }
55 #[cfg(any(feature = "derive", feature = "full"))]
56 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
57 impl Hash for AssocType {
hashnull58     fn hash<H>(&self, state: &mut H)
59     where
60         H: Hasher,
61     {
62         self.ident.hash(state);
63         self.generics.hash(state);
64         self.ty.hash(state);
65     }
66 }
67 #[cfg(any(feature = "derive", feature = "full"))]
68 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
69 impl Hash for AttrStyle {
hashnull70     fn hash<H>(&self, state: &mut H)
71     where
72         H: Hasher,
73     {
74         match self {
75             AttrStyle::Outer => {
76                 state.write_u8(0u8);
77             }
78             AttrStyle::Inner(_) => {
79                 state.write_u8(1u8);
80             }
81         }
82     }
83 }
84 #[cfg(any(feature = "derive", feature = "full"))]
85 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
86 impl Hash for Attribute {
hashnull87     fn hash<H>(&self, state: &mut H)
88     where
89         H: Hasher,
90     {
91         self.style.hash(state);
92         self.meta.hash(state);
93     }
94 }
95 #[cfg(any(feature = "derive", feature = "full"))]
96 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
97 impl Hash for BareFnArg {
hashnull98     fn hash<H>(&self, state: &mut H)
99     where
100         H: Hasher,
101     {
102         self.attrs.hash(state);
103         self.name.hash(state);
104         self.ty.hash(state);
105     }
106 }
107 #[cfg(any(feature = "derive", feature = "full"))]
108 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
109 impl Hash for BareVariadic {
hashnull110     fn hash<H>(&self, state: &mut H)
111     where
112         H: Hasher,
113     {
114         self.attrs.hash(state);
115         self.name.hash(state);
116         self.comma.hash(state);
117     }
118 }
119 #[cfg(any(feature = "derive", feature = "full"))]
120 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
121 impl Hash for BinOp {
hashnull122     fn hash<H>(&self, state: &mut H)
123     where
124         H: Hasher,
125     {
126         match self {
127             BinOp::Add(_) => {
128                 state.write_u8(0u8);
129             }
130             BinOp::Sub(_) => {
131                 state.write_u8(1u8);
132             }
133             BinOp::Mul(_) => {
134                 state.write_u8(2u8);
135             }
136             BinOp::Div(_) => {
137                 state.write_u8(3u8);
138             }
139             BinOp::Rem(_) => {
140                 state.write_u8(4u8);
141             }
142             BinOp::And(_) => {
143                 state.write_u8(5u8);
144             }
145             BinOp::Or(_) => {
146                 state.write_u8(6u8);
147             }
148             BinOp::BitXor(_) => {
149                 state.write_u8(7u8);
150             }
151             BinOp::BitAnd(_) => {
152                 state.write_u8(8u8);
153             }
154             BinOp::BitOr(_) => {
155                 state.write_u8(9u8);
156             }
157             BinOp::Shl(_) => {
158                 state.write_u8(10u8);
159             }
160             BinOp::Shr(_) => {
161                 state.write_u8(11u8);
162             }
163             BinOp::Eq(_) => {
164                 state.write_u8(12u8);
165             }
166             BinOp::Lt(_) => {
167                 state.write_u8(13u8);
168             }
169             BinOp::Le(_) => {
170                 state.write_u8(14u8);
171             }
172             BinOp::Ne(_) => {
173                 state.write_u8(15u8);
174             }
175             BinOp::Ge(_) => {
176                 state.write_u8(16u8);
177             }
178             BinOp::Gt(_) => {
179                 state.write_u8(17u8);
180             }
181             BinOp::AddAssign(_) => {
182                 state.write_u8(18u8);
183             }
184             BinOp::SubAssign(_) => {
185                 state.write_u8(19u8);
186             }
187             BinOp::MulAssign(_) => {
188                 state.write_u8(20u8);
189             }
190             BinOp::DivAssign(_) => {
191                 state.write_u8(21u8);
192             }
193             BinOp::RemAssign(_) => {
194                 state.write_u8(22u8);
195             }
196             BinOp::BitXorAssign(_) => {
197                 state.write_u8(23u8);
198             }
199             BinOp::BitAndAssign(_) => {
200                 state.write_u8(24u8);
201             }
202             BinOp::BitOrAssign(_) => {
203                 state.write_u8(25u8);
204             }
205             BinOp::ShlAssign(_) => {
206                 state.write_u8(26u8);
207             }
208             BinOp::ShrAssign(_) => {
209                 state.write_u8(27u8);
210             }
211         }
212     }
213 }
214 #[cfg(feature = "full")]
215 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
216 impl Hash for Block {
hashnull217     fn hash<H>(&self, state: &mut H)
218     where
219         H: Hasher,
220     {
221         self.stmts.hash(state);
222     }
223 }
224 #[cfg(any(feature = "derive", feature = "full"))]
225 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
226 impl Hash for BoundLifetimes {
hashnull227     fn hash<H>(&self, state: &mut H)
228     where
229         H: Hasher,
230     {
231         self.lifetimes.hash(state);
232     }
233 }
234 #[cfg(any(feature = "derive", feature = "full"))]
235 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
236 impl Hash for ConstParam {
hashnull237     fn hash<H>(&self, state: &mut H)
238     where
239         H: Hasher,
240     {
241         self.attrs.hash(state);
242         self.ident.hash(state);
243         self.ty.hash(state);
244         self.eq_token.hash(state);
245         self.default.hash(state);
246     }
247 }
248 #[cfg(any(feature = "derive", feature = "full"))]
249 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
250 impl Hash for Constraint {
hashnull251     fn hash<H>(&self, state: &mut H)
252     where
253         H: Hasher,
254     {
255         self.ident.hash(state);
256         self.generics.hash(state);
257         self.bounds.hash(state);
258     }
259 }
260 #[cfg(feature = "derive")]
261 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
262 impl Hash for Data {
hashnull263     fn hash<H>(&self, state: &mut H)
264     where
265         H: Hasher,
266     {
267         match self {
268             Data::Struct(v0) => {
269                 state.write_u8(0u8);
270                 v0.hash(state);
271             }
272             Data::Enum(v0) => {
273                 state.write_u8(1u8);
274                 v0.hash(state);
275             }
276             Data::Union(v0) => {
277                 state.write_u8(2u8);
278                 v0.hash(state);
279             }
280         }
281     }
282 }
283 #[cfg(feature = "derive")]
284 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
285 impl Hash for DataEnum {
hashnull286     fn hash<H>(&self, state: &mut H)
287     where
288         H: Hasher,
289     {
290         self.variants.hash(state);
291     }
292 }
293 #[cfg(feature = "derive")]
294 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
295 impl Hash for DataStruct {
hashnull296     fn hash<H>(&self, state: &mut H)
297     where
298         H: Hasher,
299     {
300         self.fields.hash(state);
301         self.semi_token.hash(state);
302     }
303 }
304 #[cfg(feature = "derive")]
305 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
306 impl Hash for DataUnion {
hashnull307     fn hash<H>(&self, state: &mut H)
308     where
309         H: Hasher,
310     {
311         self.fields.hash(state);
312     }
313 }
314 #[cfg(feature = "derive")]
315 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
316 impl Hash for DeriveInput {
hashnull317     fn hash<H>(&self, state: &mut H)
318     where
319         H: Hasher,
320     {
321         self.attrs.hash(state);
322         self.vis.hash(state);
323         self.ident.hash(state);
324         self.generics.hash(state);
325         self.data.hash(state);
326     }
327 }
328 #[cfg(any(feature = "derive", feature = "full"))]
329 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
330 impl Hash for Expr {
hashnull331     fn hash<H>(&self, state: &mut H)
332     where
333         H: Hasher,
334     {
335         match self {
336             #[cfg(feature = "full")]
337             Expr::Array(v0) => {
338                 state.write_u8(0u8);
339                 v0.hash(state);
340             }
341             #[cfg(feature = "full")]
342             Expr::Assign(v0) => {
343                 state.write_u8(1u8);
344                 v0.hash(state);
345             }
346             #[cfg(feature = "full")]
347             Expr::Async(v0) => {
348                 state.write_u8(2u8);
349                 v0.hash(state);
350             }
351             #[cfg(feature = "full")]
352             Expr::Await(v0) => {
353                 state.write_u8(3u8);
354                 v0.hash(state);
355             }
356             Expr::Binary(v0) => {
357                 state.write_u8(4u8);
358                 v0.hash(state);
359             }
360             #[cfg(feature = "full")]
361             Expr::Block(v0) => {
362                 state.write_u8(5u8);
363                 v0.hash(state);
364             }
365             #[cfg(feature = "full")]
366             Expr::Break(v0) => {
367                 state.write_u8(6u8);
368                 v0.hash(state);
369             }
370             Expr::Call(v0) => {
371                 state.write_u8(7u8);
372                 v0.hash(state);
373             }
374             Expr::Cast(v0) => {
375                 state.write_u8(8u8);
376                 v0.hash(state);
377             }
378             #[cfg(feature = "full")]
379             Expr::Closure(v0) => {
380                 state.write_u8(9u8);
381                 v0.hash(state);
382             }
383             #[cfg(feature = "full")]
384             Expr::Const(v0) => {
385                 state.write_u8(10u8);
386                 v0.hash(state);
387             }
388             #[cfg(feature = "full")]
389             Expr::Continue(v0) => {
390                 state.write_u8(11u8);
391                 v0.hash(state);
392             }
393             Expr::Field(v0) => {
394                 state.write_u8(12u8);
395                 v0.hash(state);
396             }
397             #[cfg(feature = "full")]
398             Expr::ForLoop(v0) => {
399                 state.write_u8(13u8);
400                 v0.hash(state);
401             }
402             Expr::Group(v0) => {
403                 state.write_u8(14u8);
404                 v0.hash(state);
405             }
406             #[cfg(feature = "full")]
407             Expr::If(v0) => {
408                 state.write_u8(15u8);
409                 v0.hash(state);
410             }
411             Expr::Index(v0) => {
412                 state.write_u8(16u8);
413                 v0.hash(state);
414             }
415             #[cfg(feature = "full")]
416             Expr::Infer(v0) => {
417                 state.write_u8(17u8);
418                 v0.hash(state);
419             }
420             #[cfg(feature = "full")]
421             Expr::Let(v0) => {
422                 state.write_u8(18u8);
423                 v0.hash(state);
424             }
425             Expr::Lit(v0) => {
426                 state.write_u8(19u8);
427                 v0.hash(state);
428             }
429             #[cfg(feature = "full")]
430             Expr::Loop(v0) => {
431                 state.write_u8(20u8);
432                 v0.hash(state);
433             }
434             Expr::Macro(v0) => {
435                 state.write_u8(21u8);
436                 v0.hash(state);
437             }
438             #[cfg(feature = "full")]
439             Expr::Match(v0) => {
440                 state.write_u8(22u8);
441                 v0.hash(state);
442             }
443             Expr::MethodCall(v0) => {
444                 state.write_u8(23u8);
445                 v0.hash(state);
446             }
447             Expr::Paren(v0) => {
448                 state.write_u8(24u8);
449                 v0.hash(state);
450             }
451             Expr::Path(v0) => {
452                 state.write_u8(25u8);
453                 v0.hash(state);
454             }
455             #[cfg(feature = "full")]
456             Expr::Range(v0) => {
457                 state.write_u8(26u8);
458                 v0.hash(state);
459             }
460             Expr::Reference(v0) => {
461                 state.write_u8(27u8);
462                 v0.hash(state);
463             }
464             #[cfg(feature = "full")]
465             Expr::Repeat(v0) => {
466                 state.write_u8(28u8);
467                 v0.hash(state);
468             }
469             #[cfg(feature = "full")]
470             Expr::Return(v0) => {
471                 state.write_u8(29u8);
472                 v0.hash(state);
473             }
474             Expr::Struct(v0) => {
475                 state.write_u8(30u8);
476                 v0.hash(state);
477             }
478             #[cfg(feature = "full")]
479             Expr::Try(v0) => {
480                 state.write_u8(31u8);
481                 v0.hash(state);
482             }
483             #[cfg(feature = "full")]
484             Expr::TryBlock(v0) => {
485                 state.write_u8(32u8);
486                 v0.hash(state);
487             }
488             #[cfg(feature = "full")]
489             Expr::Tuple(v0) => {
490                 state.write_u8(33u8);
491                 v0.hash(state);
492             }
493             Expr::Unary(v0) => {
494                 state.write_u8(34u8);
495                 v0.hash(state);
496             }
497             #[cfg(feature = "full")]
498             Expr::Unsafe(v0) => {
499                 state.write_u8(35u8);
500                 v0.hash(state);
501             }
502             Expr::Verbatim(v0) => {
503                 state.write_u8(36u8);
504                 TokenStreamHelper(v0).hash(state);
505             }
506             #[cfg(feature = "full")]
507             Expr::While(v0) => {
508                 state.write_u8(37u8);
509                 v0.hash(state);
510             }
511             #[cfg(feature = "full")]
512             Expr::Yield(v0) => {
513                 state.write_u8(38u8);
514                 v0.hash(state);
515             }
516             #[cfg(not(feature = "full"))]
517             _ => unreachable!(),
518         }
519     }
520 }
521 #[cfg(feature = "full")]
522 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
523 impl Hash for ExprArray {
hashnull524     fn hash<H>(&self, state: &mut H)
525     where
526         H: Hasher,
527     {
528         self.attrs.hash(state);
529         self.elems.hash(state);
530     }
531 }
532 #[cfg(feature = "full")]
533 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
534 impl Hash for ExprAssign {
hashnull535     fn hash<H>(&self, state: &mut H)
536     where
537         H: Hasher,
538     {
539         self.attrs.hash(state);
540         self.left.hash(state);
541         self.right.hash(state);
542     }
543 }
544 #[cfg(feature = "full")]
545 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
546 impl Hash for ExprAsync {
hashnull547     fn hash<H>(&self, state: &mut H)
548     where
549         H: Hasher,
550     {
551         self.attrs.hash(state);
552         self.capture.hash(state);
553         self.block.hash(state);
554     }
555 }
556 #[cfg(feature = "full")]
557 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
558 impl Hash for ExprAwait {
hashnull559     fn hash<H>(&self, state: &mut H)
560     where
561         H: Hasher,
562     {
563         self.attrs.hash(state);
564         self.base.hash(state);
565     }
566 }
567 #[cfg(any(feature = "derive", feature = "full"))]
568 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
569 impl Hash for ExprBinary {
hashnull570     fn hash<H>(&self, state: &mut H)
571     where
572         H: Hasher,
573     {
574         self.attrs.hash(state);
575         self.left.hash(state);
576         self.op.hash(state);
577         self.right.hash(state);
578     }
579 }
580 #[cfg(feature = "full")]
581 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
582 impl Hash for ExprBlock {
hashnull583     fn hash<H>(&self, state: &mut H)
584     where
585         H: Hasher,
586     {
587         self.attrs.hash(state);
588         self.label.hash(state);
589         self.block.hash(state);
590     }
591 }
592 #[cfg(feature = "full")]
593 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
594 impl Hash for ExprBreak {
hashnull595     fn hash<H>(&self, state: &mut H)
596     where
597         H: Hasher,
598     {
599         self.attrs.hash(state);
600         self.label.hash(state);
601         self.expr.hash(state);
602     }
603 }
604 #[cfg(any(feature = "derive", feature = "full"))]
605 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
606 impl Hash for ExprCall {
hashnull607     fn hash<H>(&self, state: &mut H)
608     where
609         H: Hasher,
610     {
611         self.attrs.hash(state);
612         self.func.hash(state);
613         self.args.hash(state);
614     }
615 }
616 #[cfg(any(feature = "derive", feature = "full"))]
617 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
618 impl Hash for ExprCast {
hashnull619     fn hash<H>(&self, state: &mut H)
620     where
621         H: Hasher,
622     {
623         self.attrs.hash(state);
624         self.expr.hash(state);
625         self.ty.hash(state);
626     }
627 }
628 #[cfg(feature = "full")]
629 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
630 impl Hash for ExprClosure {
hashnull631     fn hash<H>(&self, state: &mut H)
632     where
633         H: Hasher,
634     {
635         self.attrs.hash(state);
636         self.lifetimes.hash(state);
637         self.constness.hash(state);
638         self.movability.hash(state);
639         self.asyncness.hash(state);
640         self.capture.hash(state);
641         self.inputs.hash(state);
642         self.output.hash(state);
643         self.body.hash(state);
644     }
645 }
646 #[cfg(feature = "full")]
647 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
648 impl Hash for ExprConst {
hashnull649     fn hash<H>(&self, state: &mut H)
650     where
651         H: Hasher,
652     {
653         self.attrs.hash(state);
654         self.block.hash(state);
655     }
656 }
657 #[cfg(feature = "full")]
658 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
659 impl Hash for ExprContinue {
hashnull660     fn hash<H>(&self, state: &mut H)
661     where
662         H: Hasher,
663     {
664         self.attrs.hash(state);
665         self.label.hash(state);
666     }
667 }
668 #[cfg(any(feature = "derive", feature = "full"))]
669 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
670 impl Hash for ExprField {
hashnull671     fn hash<H>(&self, state: &mut H)
672     where
673         H: Hasher,
674     {
675         self.attrs.hash(state);
676         self.base.hash(state);
677         self.member.hash(state);
678     }
679 }
680 #[cfg(feature = "full")]
681 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
682 impl Hash for ExprForLoop {
hashnull683     fn hash<H>(&self, state: &mut H)
684     where
685         H: Hasher,
686     {
687         self.attrs.hash(state);
688         self.label.hash(state);
689         self.pat.hash(state);
690         self.expr.hash(state);
691         self.body.hash(state);
692     }
693 }
694 #[cfg(any(feature = "derive", feature = "full"))]
695 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
696 impl Hash for ExprGroup {
hashnull697     fn hash<H>(&self, state: &mut H)
698     where
699         H: Hasher,
700     {
701         self.attrs.hash(state);
702         self.expr.hash(state);
703     }
704 }
705 #[cfg(feature = "full")]
706 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
707 impl Hash for ExprIf {
hashnull708     fn hash<H>(&self, state: &mut H)
709     where
710         H: Hasher,
711     {
712         self.attrs.hash(state);
713         self.cond.hash(state);
714         self.then_branch.hash(state);
715         self.else_branch.hash(state);
716     }
717 }
718 #[cfg(any(feature = "derive", feature = "full"))]
719 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
720 impl Hash for ExprIndex {
hashnull721     fn hash<H>(&self, state: &mut H)
722     where
723         H: Hasher,
724     {
725         self.attrs.hash(state);
726         self.expr.hash(state);
727         self.index.hash(state);
728     }
729 }
730 #[cfg(feature = "full")]
731 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
732 impl Hash for ExprInfer {
hashnull733     fn hash<H>(&self, state: &mut H)
734     where
735         H: Hasher,
736     {
737         self.attrs.hash(state);
738     }
739 }
740 #[cfg(feature = "full")]
741 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
742 impl Hash for ExprLet {
hashnull743     fn hash<H>(&self, state: &mut H)
744     where
745         H: Hasher,
746     {
747         self.attrs.hash(state);
748         self.pat.hash(state);
749         self.expr.hash(state);
750     }
751 }
752 #[cfg(any(feature = "derive", feature = "full"))]
753 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
754 impl Hash for ExprLit {
hashnull755     fn hash<H>(&self, state: &mut H)
756     where
757         H: Hasher,
758     {
759         self.attrs.hash(state);
760         self.lit.hash(state);
761     }
762 }
763 #[cfg(feature = "full")]
764 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
765 impl Hash for ExprLoop {
hashnull766     fn hash<H>(&self, state: &mut H)
767     where
768         H: Hasher,
769     {
770         self.attrs.hash(state);
771         self.label.hash(state);
772         self.body.hash(state);
773     }
774 }
775 #[cfg(any(feature = "derive", feature = "full"))]
776 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
777 impl Hash for ExprMacro {
hashnull778     fn hash<H>(&self, state: &mut H)
779     where
780         H: Hasher,
781     {
782         self.attrs.hash(state);
783         self.mac.hash(state);
784     }
785 }
786 #[cfg(feature = "full")]
787 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
788 impl Hash for ExprMatch {
hashnull789     fn hash<H>(&self, state: &mut H)
790     where
791         H: Hasher,
792     {
793         self.attrs.hash(state);
794         self.expr.hash(state);
795         self.arms.hash(state);
796     }
797 }
798 #[cfg(any(feature = "derive", feature = "full"))]
799 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
800 impl Hash for ExprMethodCall {
hashnull801     fn hash<H>(&self, state: &mut H)
802     where
803         H: Hasher,
804     {
805         self.attrs.hash(state);
806         self.receiver.hash(state);
807         self.method.hash(state);
808         self.turbofish.hash(state);
809         self.args.hash(state);
810     }
811 }
812 #[cfg(any(feature = "derive", feature = "full"))]
813 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
814 impl Hash for ExprParen {
hashnull815     fn hash<H>(&self, state: &mut H)
816     where
817         H: Hasher,
818     {
819         self.attrs.hash(state);
820         self.expr.hash(state);
821     }
822 }
823 #[cfg(any(feature = "derive", feature = "full"))]
824 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
825 impl Hash for ExprPath {
hashnull826     fn hash<H>(&self, state: &mut H)
827     where
828         H: Hasher,
829     {
830         self.attrs.hash(state);
831         self.qself.hash(state);
832         self.path.hash(state);
833     }
834 }
835 #[cfg(feature = "full")]
836 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
837 impl Hash for ExprRange {
hashnull838     fn hash<H>(&self, state: &mut H)
839     where
840         H: Hasher,
841     {
842         self.attrs.hash(state);
843         self.start.hash(state);
844         self.limits.hash(state);
845         self.end.hash(state);
846     }
847 }
848 #[cfg(any(feature = "derive", feature = "full"))]
849 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
850 impl Hash for ExprReference {
hashnull851     fn hash<H>(&self, state: &mut H)
852     where
853         H: Hasher,
854     {
855         self.attrs.hash(state);
856         self.mutability.hash(state);
857         self.expr.hash(state);
858     }
859 }
860 #[cfg(feature = "full")]
861 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
862 impl Hash for ExprRepeat {
hashnull863     fn hash<H>(&self, state: &mut H)
864     where
865         H: Hasher,
866     {
867         self.attrs.hash(state);
868         self.expr.hash(state);
869         self.len.hash(state);
870     }
871 }
872 #[cfg(feature = "full")]
873 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
874 impl Hash for ExprReturn {
hashnull875     fn hash<H>(&self, state: &mut H)
876     where
877         H: Hasher,
878     {
879         self.attrs.hash(state);
880         self.expr.hash(state);
881     }
882 }
883 #[cfg(any(feature = "derive", feature = "full"))]
884 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
885 impl Hash for ExprStruct {
hashnull886     fn hash<H>(&self, state: &mut H)
887     where
888         H: Hasher,
889     {
890         self.attrs.hash(state);
891         self.qself.hash(state);
892         self.path.hash(state);
893         self.fields.hash(state);
894         self.dot2_token.hash(state);
895         self.rest.hash(state);
896     }
897 }
898 #[cfg(feature = "full")]
899 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
900 impl Hash for ExprTry {
hashnull901     fn hash<H>(&self, state: &mut H)
902     where
903         H: Hasher,
904     {
905         self.attrs.hash(state);
906         self.expr.hash(state);
907     }
908 }
909 #[cfg(feature = "full")]
910 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
911 impl Hash for ExprTryBlock {
hashnull912     fn hash<H>(&self, state: &mut H)
913     where
914         H: Hasher,
915     {
916         self.attrs.hash(state);
917         self.block.hash(state);
918     }
919 }
920 #[cfg(feature = "full")]
921 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
922 impl Hash for ExprTuple {
hashnull923     fn hash<H>(&self, state: &mut H)
924     where
925         H: Hasher,
926     {
927         self.attrs.hash(state);
928         self.elems.hash(state);
929     }
930 }
931 #[cfg(any(feature = "derive", feature = "full"))]
932 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
933 impl Hash for ExprUnary {
hashnull934     fn hash<H>(&self, state: &mut H)
935     where
936         H: Hasher,
937     {
938         self.attrs.hash(state);
939         self.op.hash(state);
940         self.expr.hash(state);
941     }
942 }
943 #[cfg(feature = "full")]
944 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
945 impl Hash for ExprUnsafe {
hashnull946     fn hash<H>(&self, state: &mut H)
947     where
948         H: Hasher,
949     {
950         self.attrs.hash(state);
951         self.block.hash(state);
952     }
953 }
954 #[cfg(feature = "full")]
955 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
956 impl Hash for ExprWhile {
hashnull957     fn hash<H>(&self, state: &mut H)
958     where
959         H: Hasher,
960     {
961         self.attrs.hash(state);
962         self.label.hash(state);
963         self.cond.hash(state);
964         self.body.hash(state);
965     }
966 }
967 #[cfg(feature = "full")]
968 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
969 impl Hash for ExprYield {
hashnull970     fn hash<H>(&self, state: &mut H)
971     where
972         H: Hasher,
973     {
974         self.attrs.hash(state);
975         self.expr.hash(state);
976     }
977 }
978 #[cfg(any(feature = "derive", feature = "full"))]
979 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
980 impl Hash for Field {
hashnull981     fn hash<H>(&self, state: &mut H)
982     where
983         H: Hasher,
984     {
985         self.attrs.hash(state);
986         self.vis.hash(state);
987         self.mutability.hash(state);
988         self.ident.hash(state);
989         self.colon_token.hash(state);
990         self.ty.hash(state);
991     }
992 }
993 #[cfg(any(feature = "derive", feature = "full"))]
994 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
995 impl Hash for FieldMutability {
hashnull996     fn hash<H>(&self, state: &mut H)
997     where
998         H: Hasher,
999     {
1000         match self {
1001             FieldMutability::None => {
1002                 state.write_u8(0u8);
1003             }
1004         }
1005     }
1006 }
1007 #[cfg(feature = "full")]
1008 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1009 impl Hash for FieldPat {
hashnull1010     fn hash<H>(&self, state: &mut H)
1011     where
1012         H: Hasher,
1013     {
1014         self.attrs.hash(state);
1015         self.member.hash(state);
1016         self.colon_token.hash(state);
1017         self.pat.hash(state);
1018     }
1019 }
1020 #[cfg(any(feature = "derive", feature = "full"))]
1021 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1022 impl Hash for FieldValue {
hashnull1023     fn hash<H>(&self, state: &mut H)
1024     where
1025         H: Hasher,
1026     {
1027         self.attrs.hash(state);
1028         self.member.hash(state);
1029         self.colon_token.hash(state);
1030         self.expr.hash(state);
1031     }
1032 }
1033 #[cfg(any(feature = "derive", feature = "full"))]
1034 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1035 impl Hash for Fields {
hashnull1036     fn hash<H>(&self, state: &mut H)
1037     where
1038         H: Hasher,
1039     {
1040         match self {
1041             Fields::Named(v0) => {
1042                 state.write_u8(0u8);
1043                 v0.hash(state);
1044             }
1045             Fields::Unnamed(v0) => {
1046                 state.write_u8(1u8);
1047                 v0.hash(state);
1048             }
1049             Fields::Unit => {
1050                 state.write_u8(2u8);
1051             }
1052         }
1053     }
1054 }
1055 #[cfg(any(feature = "derive", feature = "full"))]
1056 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1057 impl Hash for FieldsNamed {
hashnull1058     fn hash<H>(&self, state: &mut H)
1059     where
1060         H: Hasher,
1061     {
1062         self.named.hash(state);
1063     }
1064 }
1065 #[cfg(any(feature = "derive", feature = "full"))]
1066 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1067 impl Hash for FieldsUnnamed {
hashnull1068     fn hash<H>(&self, state: &mut H)
1069     where
1070         H: Hasher,
1071     {
1072         self.unnamed.hash(state);
1073     }
1074 }
1075 #[cfg(feature = "full")]
1076 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1077 impl Hash for File {
hashnull1078     fn hash<H>(&self, state: &mut H)
1079     where
1080         H: Hasher,
1081     {
1082         self.shebang.hash(state);
1083         self.attrs.hash(state);
1084         self.items.hash(state);
1085     }
1086 }
1087 #[cfg(feature = "full")]
1088 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1089 impl Hash for FnArg {
hashnull1090     fn hash<H>(&self, state: &mut H)
1091     where
1092         H: Hasher,
1093     {
1094         match self {
1095             FnArg::Receiver(v0) => {
1096                 state.write_u8(0u8);
1097                 v0.hash(state);
1098             }
1099             FnArg::Typed(v0) => {
1100                 state.write_u8(1u8);
1101                 v0.hash(state);
1102             }
1103         }
1104     }
1105 }
1106 #[cfg(feature = "full")]
1107 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1108 impl Hash for ForeignItem {
hashnull1109     fn hash<H>(&self, state: &mut H)
1110     where
1111         H: Hasher,
1112     {
1113         match self {
1114             ForeignItem::Fn(v0) => {
1115                 state.write_u8(0u8);
1116                 v0.hash(state);
1117             }
1118             ForeignItem::Static(v0) => {
1119                 state.write_u8(1u8);
1120                 v0.hash(state);
1121             }
1122             ForeignItem::Type(v0) => {
1123                 state.write_u8(2u8);
1124                 v0.hash(state);
1125             }
1126             ForeignItem::Macro(v0) => {
1127                 state.write_u8(3u8);
1128                 v0.hash(state);
1129             }
1130             ForeignItem::Verbatim(v0) => {
1131                 state.write_u8(4u8);
1132                 TokenStreamHelper(v0).hash(state);
1133             }
1134         }
1135     }
1136 }
1137 #[cfg(feature = "full")]
1138 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1139 impl Hash for ForeignItemFn {
hashnull1140     fn hash<H>(&self, state: &mut H)
1141     where
1142         H: Hasher,
1143     {
1144         self.attrs.hash(state);
1145         self.vis.hash(state);
1146         self.sig.hash(state);
1147     }
1148 }
1149 #[cfg(feature = "full")]
1150 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1151 impl Hash for ForeignItemMacro {
hashnull1152     fn hash<H>(&self, state: &mut H)
1153     where
1154         H: Hasher,
1155     {
1156         self.attrs.hash(state);
1157         self.mac.hash(state);
1158         self.semi_token.hash(state);
1159     }
1160 }
1161 #[cfg(feature = "full")]
1162 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1163 impl Hash for ForeignItemStatic {
hashnull1164     fn hash<H>(&self, state: &mut H)
1165     where
1166         H: Hasher,
1167     {
1168         self.attrs.hash(state);
1169         self.vis.hash(state);
1170         self.mutability.hash(state);
1171         self.ident.hash(state);
1172         self.ty.hash(state);
1173     }
1174 }
1175 #[cfg(feature = "full")]
1176 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1177 impl Hash for ForeignItemType {
hashnull1178     fn hash<H>(&self, state: &mut H)
1179     where
1180         H: Hasher,
1181     {
1182         self.attrs.hash(state);
1183         self.vis.hash(state);
1184         self.ident.hash(state);
1185         self.generics.hash(state);
1186     }
1187 }
1188 #[cfg(any(feature = "derive", feature = "full"))]
1189 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1190 impl Hash for GenericArgument {
hashnull1191     fn hash<H>(&self, state: &mut H)
1192     where
1193         H: Hasher,
1194     {
1195         match self {
1196             GenericArgument::Lifetime(v0) => {
1197                 state.write_u8(0u8);
1198                 v0.hash(state);
1199             }
1200             GenericArgument::Type(v0) => {
1201                 state.write_u8(1u8);
1202                 v0.hash(state);
1203             }
1204             GenericArgument::Const(v0) => {
1205                 state.write_u8(2u8);
1206                 v0.hash(state);
1207             }
1208             GenericArgument::AssocType(v0) => {
1209                 state.write_u8(3u8);
1210                 v0.hash(state);
1211             }
1212             GenericArgument::AssocConst(v0) => {
1213                 state.write_u8(4u8);
1214                 v0.hash(state);
1215             }
1216             GenericArgument::Constraint(v0) => {
1217                 state.write_u8(5u8);
1218                 v0.hash(state);
1219             }
1220         }
1221     }
1222 }
1223 #[cfg(any(feature = "derive", feature = "full"))]
1224 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1225 impl Hash for GenericParam {
hashnull1226     fn hash<H>(&self, state: &mut H)
1227     where
1228         H: Hasher,
1229     {
1230         match self {
1231             GenericParam::Lifetime(v0) => {
1232                 state.write_u8(0u8);
1233                 v0.hash(state);
1234             }
1235             GenericParam::Type(v0) => {
1236                 state.write_u8(1u8);
1237                 v0.hash(state);
1238             }
1239             GenericParam::Const(v0) => {
1240                 state.write_u8(2u8);
1241                 v0.hash(state);
1242             }
1243         }
1244     }
1245 }
1246 #[cfg(any(feature = "derive", feature = "full"))]
1247 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1248 impl Hash for Generics {
hashnull1249     fn hash<H>(&self, state: &mut H)
1250     where
1251         H: Hasher,
1252     {
1253         self.lt_token.hash(state);
1254         self.params.hash(state);
1255         self.gt_token.hash(state);
1256         self.where_clause.hash(state);
1257     }
1258 }
1259 #[cfg(feature = "full")]
1260 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1261 impl Hash for ImplItem {
hashnull1262     fn hash<H>(&self, state: &mut H)
1263     where
1264         H: Hasher,
1265     {
1266         match self {
1267             ImplItem::Const(v0) => {
1268                 state.write_u8(0u8);
1269                 v0.hash(state);
1270             }
1271             ImplItem::Fn(v0) => {
1272                 state.write_u8(1u8);
1273                 v0.hash(state);
1274             }
1275             ImplItem::Type(v0) => {
1276                 state.write_u8(2u8);
1277                 v0.hash(state);
1278             }
1279             ImplItem::Macro(v0) => {
1280                 state.write_u8(3u8);
1281                 v0.hash(state);
1282             }
1283             ImplItem::Verbatim(v0) => {
1284                 state.write_u8(4u8);
1285                 TokenStreamHelper(v0).hash(state);
1286             }
1287         }
1288     }
1289 }
1290 #[cfg(feature = "full")]
1291 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1292 impl Hash for ImplItemConst {
hashnull1293     fn hash<H>(&self, state: &mut H)
1294     where
1295         H: Hasher,
1296     {
1297         self.attrs.hash(state);
1298         self.vis.hash(state);
1299         self.defaultness.hash(state);
1300         self.ident.hash(state);
1301         self.generics.hash(state);
1302         self.ty.hash(state);
1303         self.expr.hash(state);
1304     }
1305 }
1306 #[cfg(feature = "full")]
1307 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1308 impl Hash for ImplItemFn {
hashnull1309     fn hash<H>(&self, state: &mut H)
1310     where
1311         H: Hasher,
1312     {
1313         self.attrs.hash(state);
1314         self.vis.hash(state);
1315         self.defaultness.hash(state);
1316         self.sig.hash(state);
1317         self.block.hash(state);
1318     }
1319 }
1320 #[cfg(feature = "full")]
1321 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1322 impl Hash for ImplItemMacro {
hashnull1323     fn hash<H>(&self, state: &mut H)
1324     where
1325         H: Hasher,
1326     {
1327         self.attrs.hash(state);
1328         self.mac.hash(state);
1329         self.semi_token.hash(state);
1330     }
1331 }
1332 #[cfg(feature = "full")]
1333 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1334 impl Hash for ImplItemType {
hashnull1335     fn hash<H>(&self, state: &mut H)
1336     where
1337         H: Hasher,
1338     {
1339         self.attrs.hash(state);
1340         self.vis.hash(state);
1341         self.defaultness.hash(state);
1342         self.ident.hash(state);
1343         self.generics.hash(state);
1344         self.ty.hash(state);
1345     }
1346 }
1347 #[cfg(feature = "full")]
1348 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1349 impl Hash for ImplRestriction {
hashnull1350     fn hash<H>(&self, _state: &mut H)
1351     where
1352         H: Hasher,
1353     {
1354         match *self {}
1355     }
1356 }
1357 #[cfg(feature = "full")]
1358 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1359 impl Hash for Item {
hashnull1360     fn hash<H>(&self, state: &mut H)
1361     where
1362         H: Hasher,
1363     {
1364         match self {
1365             Item::Const(v0) => {
1366                 state.write_u8(0u8);
1367                 v0.hash(state);
1368             }
1369             Item::Enum(v0) => {
1370                 state.write_u8(1u8);
1371                 v0.hash(state);
1372             }
1373             Item::ExternCrate(v0) => {
1374                 state.write_u8(2u8);
1375                 v0.hash(state);
1376             }
1377             Item::Fn(v0) => {
1378                 state.write_u8(3u8);
1379                 v0.hash(state);
1380             }
1381             Item::ForeignMod(v0) => {
1382                 state.write_u8(4u8);
1383                 v0.hash(state);
1384             }
1385             Item::Impl(v0) => {
1386                 state.write_u8(5u8);
1387                 v0.hash(state);
1388             }
1389             Item::Macro(v0) => {
1390                 state.write_u8(6u8);
1391                 v0.hash(state);
1392             }
1393             Item::Mod(v0) => {
1394                 state.write_u8(7u8);
1395                 v0.hash(state);
1396             }
1397             Item::Static(v0) => {
1398                 state.write_u8(8u8);
1399                 v0.hash(state);
1400             }
1401             Item::Struct(v0) => {
1402                 state.write_u8(9u8);
1403                 v0.hash(state);
1404             }
1405             Item::Trait(v0) => {
1406                 state.write_u8(10u8);
1407                 v0.hash(state);
1408             }
1409             Item::TraitAlias(v0) => {
1410                 state.write_u8(11u8);
1411                 v0.hash(state);
1412             }
1413             Item::Type(v0) => {
1414                 state.write_u8(12u8);
1415                 v0.hash(state);
1416             }
1417             Item::Union(v0) => {
1418                 state.write_u8(13u8);
1419                 v0.hash(state);
1420             }
1421             Item::Use(v0) => {
1422                 state.write_u8(14u8);
1423                 v0.hash(state);
1424             }
1425             Item::Verbatim(v0) => {
1426                 state.write_u8(15u8);
1427                 TokenStreamHelper(v0).hash(state);
1428             }
1429         }
1430     }
1431 }
1432 #[cfg(feature = "full")]
1433 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1434 impl Hash for ItemConst {
hashnull1435     fn hash<H>(&self, state: &mut H)
1436     where
1437         H: Hasher,
1438     {
1439         self.attrs.hash(state);
1440         self.vis.hash(state);
1441         self.ident.hash(state);
1442         self.generics.hash(state);
1443         self.ty.hash(state);
1444         self.expr.hash(state);
1445     }
1446 }
1447 #[cfg(feature = "full")]
1448 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1449 impl Hash for ItemEnum {
hashnull1450     fn hash<H>(&self, state: &mut H)
1451     where
1452         H: Hasher,
1453     {
1454         self.attrs.hash(state);
1455         self.vis.hash(state);
1456         self.ident.hash(state);
1457         self.generics.hash(state);
1458         self.variants.hash(state);
1459     }
1460 }
1461 #[cfg(feature = "full")]
1462 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1463 impl Hash for ItemExternCrate {
hashnull1464     fn hash<H>(&self, state: &mut H)
1465     where
1466         H: Hasher,
1467     {
1468         self.attrs.hash(state);
1469         self.vis.hash(state);
1470         self.ident.hash(state);
1471         self.rename.hash(state);
1472     }
1473 }
1474 #[cfg(feature = "full")]
1475 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1476 impl Hash for ItemFn {
hashnull1477     fn hash<H>(&self, state: &mut H)
1478     where
1479         H: Hasher,
1480     {
1481         self.attrs.hash(state);
1482         self.vis.hash(state);
1483         self.sig.hash(state);
1484         self.block.hash(state);
1485     }
1486 }
1487 #[cfg(feature = "full")]
1488 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1489 impl Hash for ItemForeignMod {
hashnull1490     fn hash<H>(&self, state: &mut H)
1491     where
1492         H: Hasher,
1493     {
1494         self.attrs.hash(state);
1495         self.unsafety.hash(state);
1496         self.abi.hash(state);
1497         self.items.hash(state);
1498     }
1499 }
1500 #[cfg(feature = "full")]
1501 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1502 impl Hash for ItemImpl {
hashnull1503     fn hash<H>(&self, state: &mut H)
1504     where
1505         H: Hasher,
1506     {
1507         self.attrs.hash(state);
1508         self.defaultness.hash(state);
1509         self.unsafety.hash(state);
1510         self.generics.hash(state);
1511         self.trait_.hash(state);
1512         self.self_ty.hash(state);
1513         self.items.hash(state);
1514     }
1515 }
1516 #[cfg(feature = "full")]
1517 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1518 impl Hash for ItemMacro {
hashnull1519     fn hash<H>(&self, state: &mut H)
1520     where
1521         H: Hasher,
1522     {
1523         self.attrs.hash(state);
1524         self.ident.hash(state);
1525         self.mac.hash(state);
1526         self.semi_token.hash(state);
1527     }
1528 }
1529 #[cfg(feature = "full")]
1530 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1531 impl Hash for ItemMod {
hashnull1532     fn hash<H>(&self, state: &mut H)
1533     where
1534         H: Hasher,
1535     {
1536         self.attrs.hash(state);
1537         self.vis.hash(state);
1538         self.unsafety.hash(state);
1539         self.ident.hash(state);
1540         self.content.hash(state);
1541         self.semi.hash(state);
1542     }
1543 }
1544 #[cfg(feature = "full")]
1545 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1546 impl Hash for ItemStatic {
hashnull1547     fn hash<H>(&self, state: &mut H)
1548     where
1549         H: Hasher,
1550     {
1551         self.attrs.hash(state);
1552         self.vis.hash(state);
1553         self.mutability.hash(state);
1554         self.ident.hash(state);
1555         self.ty.hash(state);
1556         self.expr.hash(state);
1557     }
1558 }
1559 #[cfg(feature = "full")]
1560 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1561 impl Hash for ItemStruct {
hashnull1562     fn hash<H>(&self, state: &mut H)
1563     where
1564         H: Hasher,
1565     {
1566         self.attrs.hash(state);
1567         self.vis.hash(state);
1568         self.ident.hash(state);
1569         self.generics.hash(state);
1570         self.fields.hash(state);
1571         self.semi_token.hash(state);
1572     }
1573 }
1574 #[cfg(feature = "full")]
1575 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1576 impl Hash for ItemTrait {
hashnull1577     fn hash<H>(&self, state: &mut H)
1578     where
1579         H: Hasher,
1580     {
1581         self.attrs.hash(state);
1582         self.vis.hash(state);
1583         self.unsafety.hash(state);
1584         self.auto_token.hash(state);
1585         self.restriction.hash(state);
1586         self.ident.hash(state);
1587         self.generics.hash(state);
1588         self.colon_token.hash(state);
1589         self.supertraits.hash(state);
1590         self.items.hash(state);
1591     }
1592 }
1593 #[cfg(feature = "full")]
1594 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1595 impl Hash for ItemTraitAlias {
hashnull1596     fn hash<H>(&self, state: &mut H)
1597     where
1598         H: Hasher,
1599     {
1600         self.attrs.hash(state);
1601         self.vis.hash(state);
1602         self.ident.hash(state);
1603         self.generics.hash(state);
1604         self.bounds.hash(state);
1605     }
1606 }
1607 #[cfg(feature = "full")]
1608 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1609 impl Hash for ItemType {
hashnull1610     fn hash<H>(&self, state: &mut H)
1611     where
1612         H: Hasher,
1613     {
1614         self.attrs.hash(state);
1615         self.vis.hash(state);
1616         self.ident.hash(state);
1617         self.generics.hash(state);
1618         self.ty.hash(state);
1619     }
1620 }
1621 #[cfg(feature = "full")]
1622 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1623 impl Hash for ItemUnion {
hashnull1624     fn hash<H>(&self, state: &mut H)
1625     where
1626         H: Hasher,
1627     {
1628         self.attrs.hash(state);
1629         self.vis.hash(state);
1630         self.ident.hash(state);
1631         self.generics.hash(state);
1632         self.fields.hash(state);
1633     }
1634 }
1635 #[cfg(feature = "full")]
1636 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1637 impl Hash for ItemUse {
hashnull1638     fn hash<H>(&self, state: &mut H)
1639     where
1640         H: Hasher,
1641     {
1642         self.attrs.hash(state);
1643         self.vis.hash(state);
1644         self.leading_colon.hash(state);
1645         self.tree.hash(state);
1646     }
1647 }
1648 #[cfg(feature = "full")]
1649 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1650 impl Hash for Label {
hashnull1651     fn hash<H>(&self, state: &mut H)
1652     where
1653         H: Hasher,
1654     {
1655         self.name.hash(state);
1656     }
1657 }
1658 #[cfg(any(feature = "derive", feature = "full"))]
1659 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1660 impl Hash for LifetimeParam {
hashnull1661     fn hash<H>(&self, state: &mut H)
1662     where
1663         H: Hasher,
1664     {
1665         self.attrs.hash(state);
1666         self.lifetime.hash(state);
1667         self.colon_token.hash(state);
1668         self.bounds.hash(state);
1669     }
1670 }
1671 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1672 impl Hash for Lit {
hashnull1673     fn hash<H>(&self, state: &mut H)
1674     where
1675         H: Hasher,
1676     {
1677         match self {
1678             Lit::Str(v0) => {
1679                 state.write_u8(0u8);
1680                 v0.hash(state);
1681             }
1682             Lit::ByteStr(v0) => {
1683                 state.write_u8(1u8);
1684                 v0.hash(state);
1685             }
1686             Lit::Byte(v0) => {
1687                 state.write_u8(2u8);
1688                 v0.hash(state);
1689             }
1690             Lit::Char(v0) => {
1691                 state.write_u8(3u8);
1692                 v0.hash(state);
1693             }
1694             Lit::Int(v0) => {
1695                 state.write_u8(4u8);
1696                 v0.hash(state);
1697             }
1698             Lit::Float(v0) => {
1699                 state.write_u8(5u8);
1700                 v0.hash(state);
1701             }
1702             Lit::Bool(v0) => {
1703                 state.write_u8(6u8);
1704                 v0.hash(state);
1705             }
1706             Lit::Verbatim(v0) => {
1707                 state.write_u8(7u8);
1708                 v0.to_string().hash(state);
1709             }
1710         }
1711     }
1712 }
1713 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1714 impl Hash for LitBool {
hashnull1715     fn hash<H>(&self, state: &mut H)
1716     where
1717         H: Hasher,
1718     {
1719         self.value.hash(state);
1720     }
1721 }
1722 #[cfg(feature = "full")]
1723 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1724 impl Hash for Local {
hashnull1725     fn hash<H>(&self, state: &mut H)
1726     where
1727         H: Hasher,
1728     {
1729         self.attrs.hash(state);
1730         self.pat.hash(state);
1731         self.init.hash(state);
1732     }
1733 }
1734 #[cfg(feature = "full")]
1735 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1736 impl Hash for LocalInit {
hashnull1737     fn hash<H>(&self, state: &mut H)
1738     where
1739         H: Hasher,
1740     {
1741         self.expr.hash(state);
1742         self.diverge.hash(state);
1743     }
1744 }
1745 #[cfg(any(feature = "derive", feature = "full"))]
1746 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1747 impl Hash for Macro {
hashnull1748     fn hash<H>(&self, state: &mut H)
1749     where
1750         H: Hasher,
1751     {
1752         self.path.hash(state);
1753         self.delimiter.hash(state);
1754         TokenStreamHelper(&self.tokens).hash(state);
1755     }
1756 }
1757 #[cfg(any(feature = "derive", feature = "full"))]
1758 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1759 impl Hash for MacroDelimiter {
hashnull1760     fn hash<H>(&self, state: &mut H)
1761     where
1762         H: Hasher,
1763     {
1764         match self {
1765             MacroDelimiter::Paren(_) => {
1766                 state.write_u8(0u8);
1767             }
1768             MacroDelimiter::Brace(_) => {
1769                 state.write_u8(1u8);
1770             }
1771             MacroDelimiter::Bracket(_) => {
1772                 state.write_u8(2u8);
1773             }
1774         }
1775     }
1776 }
1777 #[cfg(any(feature = "derive", feature = "full"))]
1778 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1779 impl Hash for Meta {
hashnull1780     fn hash<H>(&self, state: &mut H)
1781     where
1782         H: Hasher,
1783     {
1784         match self {
1785             Meta::Path(v0) => {
1786                 state.write_u8(0u8);
1787                 v0.hash(state);
1788             }
1789             Meta::List(v0) => {
1790                 state.write_u8(1u8);
1791                 v0.hash(state);
1792             }
1793             Meta::NameValue(v0) => {
1794                 state.write_u8(2u8);
1795                 v0.hash(state);
1796             }
1797         }
1798     }
1799 }
1800 #[cfg(any(feature = "derive", feature = "full"))]
1801 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1802 impl Hash for MetaList {
hashnull1803     fn hash<H>(&self, state: &mut H)
1804     where
1805         H: Hasher,
1806     {
1807         self.path.hash(state);
1808         self.delimiter.hash(state);
1809         TokenStreamHelper(&self.tokens).hash(state);
1810     }
1811 }
1812 #[cfg(any(feature = "derive", feature = "full"))]
1813 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1814 impl Hash for MetaNameValue {
hashnull1815     fn hash<H>(&self, state: &mut H)
1816     where
1817         H: Hasher,
1818     {
1819         self.path.hash(state);
1820         self.value.hash(state);
1821     }
1822 }
1823 #[cfg(any(feature = "derive", feature = "full"))]
1824 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1825 impl Hash for ParenthesizedGenericArguments {
hashnull1826     fn hash<H>(&self, state: &mut H)
1827     where
1828         H: Hasher,
1829     {
1830         self.inputs.hash(state);
1831         self.output.hash(state);
1832     }
1833 }
1834 #[cfg(feature = "full")]
1835 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1836 impl Hash for Pat {
hashnull1837     fn hash<H>(&self, state: &mut H)
1838     where
1839         H: Hasher,
1840     {
1841         match self {
1842             Pat::Const(v0) => {
1843                 state.write_u8(0u8);
1844                 v0.hash(state);
1845             }
1846             Pat::Ident(v0) => {
1847                 state.write_u8(1u8);
1848                 v0.hash(state);
1849             }
1850             Pat::Lit(v0) => {
1851                 state.write_u8(2u8);
1852                 v0.hash(state);
1853             }
1854             Pat::Macro(v0) => {
1855                 state.write_u8(3u8);
1856                 v0.hash(state);
1857             }
1858             Pat::Or(v0) => {
1859                 state.write_u8(4u8);
1860                 v0.hash(state);
1861             }
1862             Pat::Paren(v0) => {
1863                 state.write_u8(5u8);
1864                 v0.hash(state);
1865             }
1866             Pat::Path(v0) => {
1867                 state.write_u8(6u8);
1868                 v0.hash(state);
1869             }
1870             Pat::Range(v0) => {
1871                 state.write_u8(7u8);
1872                 v0.hash(state);
1873             }
1874             Pat::Reference(v0) => {
1875                 state.write_u8(8u8);
1876                 v0.hash(state);
1877             }
1878             Pat::Rest(v0) => {
1879                 state.write_u8(9u8);
1880                 v0.hash(state);
1881             }
1882             Pat::Slice(v0) => {
1883                 state.write_u8(10u8);
1884                 v0.hash(state);
1885             }
1886             Pat::Struct(v0) => {
1887                 state.write_u8(11u8);
1888                 v0.hash(state);
1889             }
1890             Pat::Tuple(v0) => {
1891                 state.write_u8(12u8);
1892                 v0.hash(state);
1893             }
1894             Pat::TupleStruct(v0) => {
1895                 state.write_u8(13u8);
1896                 v0.hash(state);
1897             }
1898             Pat::Type(v0) => {
1899                 state.write_u8(14u8);
1900                 v0.hash(state);
1901             }
1902             Pat::Verbatim(v0) => {
1903                 state.write_u8(15u8);
1904                 TokenStreamHelper(v0).hash(state);
1905             }
1906             Pat::Wild(v0) => {
1907                 state.write_u8(16u8);
1908                 v0.hash(state);
1909             }
1910         }
1911     }
1912 }
1913 #[cfg(feature = "full")]
1914 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1915 impl Hash for PatIdent {
hashnull1916     fn hash<H>(&self, state: &mut H)
1917     where
1918         H: Hasher,
1919     {
1920         self.attrs.hash(state);
1921         self.by_ref.hash(state);
1922         self.mutability.hash(state);
1923         self.ident.hash(state);
1924         self.subpat.hash(state);
1925     }
1926 }
1927 #[cfg(feature = "full")]
1928 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1929 impl Hash for PatOr {
hashnull1930     fn hash<H>(&self, state: &mut H)
1931     where
1932         H: Hasher,
1933     {
1934         self.attrs.hash(state);
1935         self.leading_vert.hash(state);
1936         self.cases.hash(state);
1937     }
1938 }
1939 #[cfg(feature = "full")]
1940 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1941 impl Hash for PatParen {
hashnull1942     fn hash<H>(&self, state: &mut H)
1943     where
1944         H: Hasher,
1945     {
1946         self.attrs.hash(state);
1947         self.pat.hash(state);
1948     }
1949 }
1950 #[cfg(feature = "full")]
1951 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1952 impl Hash for PatReference {
hashnull1953     fn hash<H>(&self, state: &mut H)
1954     where
1955         H: Hasher,
1956     {
1957         self.attrs.hash(state);
1958         self.mutability.hash(state);
1959         self.pat.hash(state);
1960     }
1961 }
1962 #[cfg(feature = "full")]
1963 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1964 impl Hash for PatRest {
hashnull1965     fn hash<H>(&self, state: &mut H)
1966     where
1967         H: Hasher,
1968     {
1969         self.attrs.hash(state);
1970     }
1971 }
1972 #[cfg(feature = "full")]
1973 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1974 impl Hash for PatSlice {
hashnull1975     fn hash<H>(&self, state: &mut H)
1976     where
1977         H: Hasher,
1978     {
1979         self.attrs.hash(state);
1980         self.elems.hash(state);
1981     }
1982 }
1983 #[cfg(feature = "full")]
1984 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1985 impl Hash for PatStruct {
hashnull1986     fn hash<H>(&self, state: &mut H)
1987     where
1988         H: Hasher,
1989     {
1990         self.attrs.hash(state);
1991         self.qself.hash(state);
1992         self.path.hash(state);
1993         self.fields.hash(state);
1994         self.rest.hash(state);
1995     }
1996 }
1997 #[cfg(feature = "full")]
1998 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
1999 impl Hash for PatTuple {
hashnull2000     fn hash<H>(&self, state: &mut H)
2001     where
2002         H: Hasher,
2003     {
2004         self.attrs.hash(state);
2005         self.elems.hash(state);
2006     }
2007 }
2008 #[cfg(feature = "full")]
2009 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2010 impl Hash for PatTupleStruct {
hashnull2011     fn hash<H>(&self, state: &mut H)
2012     where
2013         H: Hasher,
2014     {
2015         self.attrs.hash(state);
2016         self.qself.hash(state);
2017         self.path.hash(state);
2018         self.elems.hash(state);
2019     }
2020 }
2021 #[cfg(feature = "full")]
2022 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2023 impl Hash for PatType {
hashnull2024     fn hash<H>(&self, state: &mut H)
2025     where
2026         H: Hasher,
2027     {
2028         self.attrs.hash(state);
2029         self.pat.hash(state);
2030         self.ty.hash(state);
2031     }
2032 }
2033 #[cfg(feature = "full")]
2034 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2035 impl Hash for PatWild {
hashnull2036     fn hash<H>(&self, state: &mut H)
2037     where
2038         H: Hasher,
2039     {
2040         self.attrs.hash(state);
2041     }
2042 }
2043 #[cfg(any(feature = "derive", feature = "full"))]
2044 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2045 impl Hash for Path {
hashnull2046     fn hash<H>(&self, state: &mut H)
2047     where
2048         H: Hasher,
2049     {
2050         self.leading_colon.hash(state);
2051         self.segments.hash(state);
2052     }
2053 }
2054 #[cfg(any(feature = "derive", feature = "full"))]
2055 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2056 impl Hash for PathArguments {
hashnull2057     fn hash<H>(&self, state: &mut H)
2058     where
2059         H: Hasher,
2060     {
2061         match self {
2062             PathArguments::None => {
2063                 state.write_u8(0u8);
2064             }
2065             PathArguments::AngleBracketed(v0) => {
2066                 state.write_u8(1u8);
2067                 v0.hash(state);
2068             }
2069             PathArguments::Parenthesized(v0) => {
2070                 state.write_u8(2u8);
2071                 v0.hash(state);
2072             }
2073         }
2074     }
2075 }
2076 #[cfg(any(feature = "derive", feature = "full"))]
2077 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2078 impl Hash for PathSegment {
hashnull2079     fn hash<H>(&self, state: &mut H)
2080     where
2081         H: Hasher,
2082     {
2083         self.ident.hash(state);
2084         self.arguments.hash(state);
2085     }
2086 }
2087 #[cfg(any(feature = "derive", feature = "full"))]
2088 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2089 impl Hash for PredicateLifetime {
hashnull2090     fn hash<H>(&self, state: &mut H)
2091     where
2092         H: Hasher,
2093     {
2094         self.lifetime.hash(state);
2095         self.bounds.hash(state);
2096     }
2097 }
2098 #[cfg(any(feature = "derive", feature = "full"))]
2099 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2100 impl Hash for PredicateType {
hashnull2101     fn hash<H>(&self, state: &mut H)
2102     where
2103         H: Hasher,
2104     {
2105         self.lifetimes.hash(state);
2106         self.bounded_ty.hash(state);
2107         self.bounds.hash(state);
2108     }
2109 }
2110 #[cfg(any(feature = "derive", feature = "full"))]
2111 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2112 impl Hash for QSelf {
hashnull2113     fn hash<H>(&self, state: &mut H)
2114     where
2115         H: Hasher,
2116     {
2117         self.ty.hash(state);
2118         self.position.hash(state);
2119         self.as_token.hash(state);
2120     }
2121 }
2122 #[cfg(feature = "full")]
2123 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2124 impl Hash for RangeLimits {
hashnull2125     fn hash<H>(&self, state: &mut H)
2126     where
2127         H: Hasher,
2128     {
2129         match self {
2130             RangeLimits::HalfOpen(_) => {
2131                 state.write_u8(0u8);
2132             }
2133             RangeLimits::Closed(_) => {
2134                 state.write_u8(1u8);
2135             }
2136         }
2137     }
2138 }
2139 #[cfg(feature = "full")]
2140 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2141 impl Hash for Receiver {
hashnull2142     fn hash<H>(&self, state: &mut H)
2143     where
2144         H: Hasher,
2145     {
2146         self.attrs.hash(state);
2147         self.reference.hash(state);
2148         self.mutability.hash(state);
2149         self.colon_token.hash(state);
2150         self.ty.hash(state);
2151     }
2152 }
2153 #[cfg(any(feature = "derive", feature = "full"))]
2154 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2155 impl Hash for ReturnType {
hashnull2156     fn hash<H>(&self, state: &mut H)
2157     where
2158         H: Hasher,
2159     {
2160         match self {
2161             ReturnType::Default => {
2162                 state.write_u8(0u8);
2163             }
2164             ReturnType::Type(_, v1) => {
2165                 state.write_u8(1u8);
2166                 v1.hash(state);
2167             }
2168         }
2169     }
2170 }
2171 #[cfg(feature = "full")]
2172 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2173 impl Hash for Signature {
hashnull2174     fn hash<H>(&self, state: &mut H)
2175     where
2176         H: Hasher,
2177     {
2178         self.constness.hash(state);
2179         self.asyncness.hash(state);
2180         self.unsafety.hash(state);
2181         self.abi.hash(state);
2182         self.ident.hash(state);
2183         self.generics.hash(state);
2184         self.inputs.hash(state);
2185         self.variadic.hash(state);
2186         self.output.hash(state);
2187     }
2188 }
2189 #[cfg(feature = "full")]
2190 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2191 impl Hash for StaticMutability {
hashnull2192     fn hash<H>(&self, state: &mut H)
2193     where
2194         H: Hasher,
2195     {
2196         match self {
2197             StaticMutability::Mut(_) => {
2198                 state.write_u8(0u8);
2199             }
2200             StaticMutability::None => {
2201                 state.write_u8(1u8);
2202             }
2203         }
2204     }
2205 }
2206 #[cfg(feature = "full")]
2207 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2208 impl Hash for Stmt {
hashnull2209     fn hash<H>(&self, state: &mut H)
2210     where
2211         H: Hasher,
2212     {
2213         match self {
2214             Stmt::Local(v0) => {
2215                 state.write_u8(0u8);
2216                 v0.hash(state);
2217             }
2218             Stmt::Item(v0) => {
2219                 state.write_u8(1u8);
2220                 v0.hash(state);
2221             }
2222             Stmt::Expr(v0, v1) => {
2223                 state.write_u8(2u8);
2224                 v0.hash(state);
2225                 v1.hash(state);
2226             }
2227             Stmt::Macro(v0) => {
2228                 state.write_u8(3u8);
2229                 v0.hash(state);
2230             }
2231         }
2232     }
2233 }
2234 #[cfg(feature = "full")]
2235 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2236 impl Hash for StmtMacro {
hashnull2237     fn hash<H>(&self, state: &mut H)
2238     where
2239         H: Hasher,
2240     {
2241         self.attrs.hash(state);
2242         self.mac.hash(state);
2243         self.semi_token.hash(state);
2244     }
2245 }
2246 #[cfg(any(feature = "derive", feature = "full"))]
2247 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2248 impl Hash for TraitBound {
hashnull2249     fn hash<H>(&self, state: &mut H)
2250     where
2251         H: Hasher,
2252     {
2253         self.paren_token.hash(state);
2254         self.modifier.hash(state);
2255         self.lifetimes.hash(state);
2256         self.path.hash(state);
2257     }
2258 }
2259 #[cfg(any(feature = "derive", feature = "full"))]
2260 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2261 impl Hash for TraitBoundModifier {
hashnull2262     fn hash<H>(&self, state: &mut H)
2263     where
2264         H: Hasher,
2265     {
2266         match self {
2267             TraitBoundModifier::None => {
2268                 state.write_u8(0u8);
2269             }
2270             TraitBoundModifier::Maybe(_) => {
2271                 state.write_u8(1u8);
2272             }
2273         }
2274     }
2275 }
2276 #[cfg(feature = "full")]
2277 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2278 impl Hash for TraitItem {
hashnull2279     fn hash<H>(&self, state: &mut H)
2280     where
2281         H: Hasher,
2282     {
2283         match self {
2284             TraitItem::Const(v0) => {
2285                 state.write_u8(0u8);
2286                 v0.hash(state);
2287             }
2288             TraitItem::Fn(v0) => {
2289                 state.write_u8(1u8);
2290                 v0.hash(state);
2291             }
2292             TraitItem::Type(v0) => {
2293                 state.write_u8(2u8);
2294                 v0.hash(state);
2295             }
2296             TraitItem::Macro(v0) => {
2297                 state.write_u8(3u8);
2298                 v0.hash(state);
2299             }
2300             TraitItem::Verbatim(v0) => {
2301                 state.write_u8(4u8);
2302                 TokenStreamHelper(v0).hash(state);
2303             }
2304         }
2305     }
2306 }
2307 #[cfg(feature = "full")]
2308 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2309 impl Hash for TraitItemConst {
hashnull2310     fn hash<H>(&self, state: &mut H)
2311     where
2312         H: Hasher,
2313     {
2314         self.attrs.hash(state);
2315         self.ident.hash(state);
2316         self.generics.hash(state);
2317         self.ty.hash(state);
2318         self.default.hash(state);
2319     }
2320 }
2321 #[cfg(feature = "full")]
2322 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2323 impl Hash for TraitItemFn {
hashnull2324     fn hash<H>(&self, state: &mut H)
2325     where
2326         H: Hasher,
2327     {
2328         self.attrs.hash(state);
2329         self.sig.hash(state);
2330         self.default.hash(state);
2331         self.semi_token.hash(state);
2332     }
2333 }
2334 #[cfg(feature = "full")]
2335 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2336 impl Hash for TraitItemMacro {
hashnull2337     fn hash<H>(&self, state: &mut H)
2338     where
2339         H: Hasher,
2340     {
2341         self.attrs.hash(state);
2342         self.mac.hash(state);
2343         self.semi_token.hash(state);
2344     }
2345 }
2346 #[cfg(feature = "full")]
2347 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2348 impl Hash for TraitItemType {
hashnull2349     fn hash<H>(&self, state: &mut H)
2350     where
2351         H: Hasher,
2352     {
2353         self.attrs.hash(state);
2354         self.ident.hash(state);
2355         self.generics.hash(state);
2356         self.colon_token.hash(state);
2357         self.bounds.hash(state);
2358         self.default.hash(state);
2359     }
2360 }
2361 #[cfg(any(feature = "derive", feature = "full"))]
2362 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2363 impl Hash for Type {
hashnull2364     fn hash<H>(&self, state: &mut H)
2365     where
2366         H: Hasher,
2367     {
2368         match self {
2369             Type::Array(v0) => {
2370                 state.write_u8(0u8);
2371                 v0.hash(state);
2372             }
2373             Type::BareFn(v0) => {
2374                 state.write_u8(1u8);
2375                 v0.hash(state);
2376             }
2377             Type::Group(v0) => {
2378                 state.write_u8(2u8);
2379                 v0.hash(state);
2380             }
2381             Type::ImplTrait(v0) => {
2382                 state.write_u8(3u8);
2383                 v0.hash(state);
2384             }
2385             Type::Infer(v0) => {
2386                 state.write_u8(4u8);
2387                 v0.hash(state);
2388             }
2389             Type::Macro(v0) => {
2390                 state.write_u8(5u8);
2391                 v0.hash(state);
2392             }
2393             Type::Never(v0) => {
2394                 state.write_u8(6u8);
2395                 v0.hash(state);
2396             }
2397             Type::Paren(v0) => {
2398                 state.write_u8(7u8);
2399                 v0.hash(state);
2400             }
2401             Type::Path(v0) => {
2402                 state.write_u8(8u8);
2403                 v0.hash(state);
2404             }
2405             Type::Ptr(v0) => {
2406                 state.write_u8(9u8);
2407                 v0.hash(state);
2408             }
2409             Type::Reference(v0) => {
2410                 state.write_u8(10u8);
2411                 v0.hash(state);
2412             }
2413             Type::Slice(v0) => {
2414                 state.write_u8(11u8);
2415                 v0.hash(state);
2416             }
2417             Type::TraitObject(v0) => {
2418                 state.write_u8(12u8);
2419                 v0.hash(state);
2420             }
2421             Type::Tuple(v0) => {
2422                 state.write_u8(13u8);
2423                 v0.hash(state);
2424             }
2425             Type::Verbatim(v0) => {
2426                 state.write_u8(14u8);
2427                 TokenStreamHelper(v0).hash(state);
2428             }
2429         }
2430     }
2431 }
2432 #[cfg(any(feature = "derive", feature = "full"))]
2433 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2434 impl Hash for TypeArray {
hashnull2435     fn hash<H>(&self, state: &mut H)
2436     where
2437         H: Hasher,
2438     {
2439         self.elem.hash(state);
2440         self.len.hash(state);
2441     }
2442 }
2443 #[cfg(any(feature = "derive", feature = "full"))]
2444 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2445 impl Hash for TypeBareFn {
hashnull2446     fn hash<H>(&self, state: &mut H)
2447     where
2448         H: Hasher,
2449     {
2450         self.lifetimes.hash(state);
2451         self.unsafety.hash(state);
2452         self.abi.hash(state);
2453         self.inputs.hash(state);
2454         self.variadic.hash(state);
2455         self.output.hash(state);
2456     }
2457 }
2458 #[cfg(any(feature = "derive", feature = "full"))]
2459 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2460 impl Hash for TypeGroup {
hashnull2461     fn hash<H>(&self, state: &mut H)
2462     where
2463         H: Hasher,
2464     {
2465         self.elem.hash(state);
2466     }
2467 }
2468 #[cfg(any(feature = "derive", feature = "full"))]
2469 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2470 impl Hash for TypeImplTrait {
hashnull2471     fn hash<H>(&self, state: &mut H)
2472     where
2473         H: Hasher,
2474     {
2475         self.bounds.hash(state);
2476     }
2477 }
2478 #[cfg(any(feature = "derive", feature = "full"))]
2479 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2480 impl Hash for TypeInfer {
hashnull2481     fn hash<H>(&self, _state: &mut H)
2482     where
2483         H: Hasher,
2484     {}
2485 }
2486 #[cfg(any(feature = "derive", feature = "full"))]
2487 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2488 impl Hash for TypeMacro {
hashnull2489     fn hash<H>(&self, state: &mut H)
2490     where
2491         H: Hasher,
2492     {
2493         self.mac.hash(state);
2494     }
2495 }
2496 #[cfg(any(feature = "derive", feature = "full"))]
2497 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2498 impl Hash for TypeNever {
hashnull2499     fn hash<H>(&self, _state: &mut H)
2500     where
2501         H: Hasher,
2502     {}
2503 }
2504 #[cfg(any(feature = "derive", feature = "full"))]
2505 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2506 impl Hash for TypeParam {
hashnull2507     fn hash<H>(&self, state: &mut H)
2508     where
2509         H: Hasher,
2510     {
2511         self.attrs.hash(state);
2512         self.ident.hash(state);
2513         self.colon_token.hash(state);
2514         self.bounds.hash(state);
2515         self.eq_token.hash(state);
2516         self.default.hash(state);
2517     }
2518 }
2519 #[cfg(any(feature = "derive", feature = "full"))]
2520 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2521 impl Hash for TypeParamBound {
hashnull2522     fn hash<H>(&self, state: &mut H)
2523     where
2524         H: Hasher,
2525     {
2526         match self {
2527             TypeParamBound::Trait(v0) => {
2528                 state.write_u8(0u8);
2529                 v0.hash(state);
2530             }
2531             TypeParamBound::Lifetime(v0) => {
2532                 state.write_u8(1u8);
2533                 v0.hash(state);
2534             }
2535             TypeParamBound::Verbatim(v0) => {
2536                 state.write_u8(2u8);
2537                 TokenStreamHelper(v0).hash(state);
2538             }
2539         }
2540     }
2541 }
2542 #[cfg(any(feature = "derive", feature = "full"))]
2543 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2544 impl Hash for TypeParen {
hashnull2545     fn hash<H>(&self, state: &mut H)
2546     where
2547         H: Hasher,
2548     {
2549         self.elem.hash(state);
2550     }
2551 }
2552 #[cfg(any(feature = "derive", feature = "full"))]
2553 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2554 impl Hash for TypePath {
hashnull2555     fn hash<H>(&self, state: &mut H)
2556     where
2557         H: Hasher,
2558     {
2559         self.qself.hash(state);
2560         self.path.hash(state);
2561     }
2562 }
2563 #[cfg(any(feature = "derive", feature = "full"))]
2564 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2565 impl Hash for TypePtr {
hashnull2566     fn hash<H>(&self, state: &mut H)
2567     where
2568         H: Hasher,
2569     {
2570         self.const_token.hash(state);
2571         self.mutability.hash(state);
2572         self.elem.hash(state);
2573     }
2574 }
2575 #[cfg(any(feature = "derive", feature = "full"))]
2576 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2577 impl Hash for TypeReference {
hashnull2578     fn hash<H>(&self, state: &mut H)
2579     where
2580         H: Hasher,
2581     {
2582         self.lifetime.hash(state);
2583         self.mutability.hash(state);
2584         self.elem.hash(state);
2585     }
2586 }
2587 #[cfg(any(feature = "derive", feature = "full"))]
2588 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2589 impl Hash for TypeSlice {
hashnull2590     fn hash<H>(&self, state: &mut H)
2591     where
2592         H: Hasher,
2593     {
2594         self.elem.hash(state);
2595     }
2596 }
2597 #[cfg(any(feature = "derive", feature = "full"))]
2598 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2599 impl Hash for TypeTraitObject {
hashnull2600     fn hash<H>(&self, state: &mut H)
2601     where
2602         H: Hasher,
2603     {
2604         self.dyn_token.hash(state);
2605         self.bounds.hash(state);
2606     }
2607 }
2608 #[cfg(any(feature = "derive", feature = "full"))]
2609 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2610 impl Hash for TypeTuple {
hashnull2611     fn hash<H>(&self, state: &mut H)
2612     where
2613         H: Hasher,
2614     {
2615         self.elems.hash(state);
2616     }
2617 }
2618 #[cfg(any(feature = "derive", feature = "full"))]
2619 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2620 impl Hash for UnOp {
hashnull2621     fn hash<H>(&self, state: &mut H)
2622     where
2623         H: Hasher,
2624     {
2625         match self {
2626             UnOp::Deref(_) => {
2627                 state.write_u8(0u8);
2628             }
2629             UnOp::Not(_) => {
2630                 state.write_u8(1u8);
2631             }
2632             UnOp::Neg(_) => {
2633                 state.write_u8(2u8);
2634             }
2635         }
2636     }
2637 }
2638 #[cfg(feature = "full")]
2639 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2640 impl Hash for UseGlob {
hashnull2641     fn hash<H>(&self, _state: &mut H)
2642     where
2643         H: Hasher,
2644     {}
2645 }
2646 #[cfg(feature = "full")]
2647 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2648 impl Hash for UseGroup {
hashnull2649     fn hash<H>(&self, state: &mut H)
2650     where
2651         H: Hasher,
2652     {
2653         self.items.hash(state);
2654     }
2655 }
2656 #[cfg(feature = "full")]
2657 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2658 impl Hash for UseName {
hashnull2659     fn hash<H>(&self, state: &mut H)
2660     where
2661         H: Hasher,
2662     {
2663         self.ident.hash(state);
2664     }
2665 }
2666 #[cfg(feature = "full")]
2667 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2668 impl Hash for UsePath {
hashnull2669     fn hash<H>(&self, state: &mut H)
2670     where
2671         H: Hasher,
2672     {
2673         self.ident.hash(state);
2674         self.tree.hash(state);
2675     }
2676 }
2677 #[cfg(feature = "full")]
2678 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2679 impl Hash for UseRename {
hashnull2680     fn hash<H>(&self, state: &mut H)
2681     where
2682         H: Hasher,
2683     {
2684         self.ident.hash(state);
2685         self.rename.hash(state);
2686     }
2687 }
2688 #[cfg(feature = "full")]
2689 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2690 impl Hash for UseTree {
hashnull2691     fn hash<H>(&self, state: &mut H)
2692     where
2693         H: Hasher,
2694     {
2695         match self {
2696             UseTree::Path(v0) => {
2697                 state.write_u8(0u8);
2698                 v0.hash(state);
2699             }
2700             UseTree::Name(v0) => {
2701                 state.write_u8(1u8);
2702                 v0.hash(state);
2703             }
2704             UseTree::Rename(v0) => {
2705                 state.write_u8(2u8);
2706                 v0.hash(state);
2707             }
2708             UseTree::Glob(v0) => {
2709                 state.write_u8(3u8);
2710                 v0.hash(state);
2711             }
2712             UseTree::Group(v0) => {
2713                 state.write_u8(4u8);
2714                 v0.hash(state);
2715             }
2716         }
2717     }
2718 }
2719 #[cfg(feature = "full")]
2720 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2721 impl Hash for Variadic {
hashnull2722     fn hash<H>(&self, state: &mut H)
2723     where
2724         H: Hasher,
2725     {
2726         self.attrs.hash(state);
2727         self.pat.hash(state);
2728         self.comma.hash(state);
2729     }
2730 }
2731 #[cfg(any(feature = "derive", feature = "full"))]
2732 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2733 impl Hash for Variant {
hashnull2734     fn hash<H>(&self, state: &mut H)
2735     where
2736         H: Hasher,
2737     {
2738         self.attrs.hash(state);
2739         self.ident.hash(state);
2740         self.fields.hash(state);
2741         self.discriminant.hash(state);
2742     }
2743 }
2744 #[cfg(any(feature = "derive", feature = "full"))]
2745 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2746 impl Hash for VisRestricted {
hashnull2747     fn hash<H>(&self, state: &mut H)
2748     where
2749         H: Hasher,
2750     {
2751         self.in_token.hash(state);
2752         self.path.hash(state);
2753     }
2754 }
2755 #[cfg(any(feature = "derive", feature = "full"))]
2756 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2757 impl Hash for Visibility {
hashnull2758     fn hash<H>(&self, state: &mut H)
2759     where
2760         H: Hasher,
2761     {
2762         match self {
2763             Visibility::Public(_) => {
2764                 state.write_u8(0u8);
2765             }
2766             Visibility::Restricted(v0) => {
2767                 state.write_u8(1u8);
2768                 v0.hash(state);
2769             }
2770             Visibility::Inherited => {
2771                 state.write_u8(2u8);
2772             }
2773         }
2774     }
2775 }
2776 #[cfg(any(feature = "derive", feature = "full"))]
2777 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2778 impl Hash for WhereClause {
hashnull2779     fn hash<H>(&self, state: &mut H)
2780     where
2781         H: Hasher,
2782     {
2783         self.predicates.hash(state);
2784     }
2785 }
2786 #[cfg(any(feature = "derive", feature = "full"))]
2787 #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
2788 impl Hash for WherePredicate {
hashnull2789     fn hash<H>(&self, state: &mut H)
2790     where
2791         H: Hasher,
2792     {
2793         match self {
2794             WherePredicate::Lifetime(v0) => {
2795                 state.write_u8(0u8);
2796                 v0.hash(state);
2797             }
2798             WherePredicate::Type(v0) => {
2799                 state.write_u8(1u8);
2800                 v0.hash(state);
2801             }
2802         }
2803     }
2804 }
2805