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