Lines Matching defs:clone
7 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
9 fn clone(&self) -> Self {
11 extern_token: self.extern_token.clone(),
12 name: self.name.clone(),
17 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
19 fn clone(&self) -> Self {
21 colon2_token: self.colon2_token.clone(),
22 lt_token: self.lt_token.clone(),
23 args: self.args.clone(),
24 gt_token: self.gt_token.clone(),
29 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
31 fn clone(&self) -> Self {
33 attrs: self.attrs.clone(),
34 pat: self.pat.clone(),
35 guard: self.guard.clone(),
36 fat_arrow_token: self.fat_arrow_token.clone(),
37 body: self.body.clone(),
38 comma: self.comma.clone(),
43 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
45 fn clone(&self) -> Self {
47 ident: self.ident.clone(),
48 generics: self.generics.clone(),
49 eq_token: self.eq_token.clone(),
50 value: self.value.clone(),
55 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
57 fn clone(&self) -> Self {
59 ident: self.ident.clone(),
60 generics: self.generics.clone(),
61 eq_token: self.eq_token.clone(),
62 ty: self.ty.clone(),
67 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
70 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
72 fn clone(&self) -> Self {
77 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
79 fn clone(&self) -> Self {
81 pound_token: self.pound_token.clone(),
82 style: self.style.clone(),
83 bracket_token: self.bracket_token.clone(),
84 meta: self.meta.clone(),
89 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
91 fn clone(&self) -> Self {
93 attrs: self.attrs.clone(),
94 name: self.name.clone(),
95 ty: self.ty.clone(),
100 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
102 fn clone(&self) -> Self {
104 attrs: self.attrs.clone(),
105 name: self.name.clone(),
106 dots: self.dots.clone(),
107 comma: self.comma.clone(),
112 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
115 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
117 fn clone(&self) -> Self {
122 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
124 fn clone(&self) -> Self {
126 brace_token: self.brace_token.clone(),
127 stmts: self.stmts.clone(),
132 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
134 fn clone(&self) -> Self {
136 for_token: self.for_token.clone(),
137 lt_token: self.lt_token.clone(),
138 lifetimes: self.lifetimes.clone(),
139 gt_token: self.gt_token.clone(),
144 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
146 fn clone(&self) -> Self {
148 attrs: self.attrs.clone(),
149 const_token: self.const_token.clone(),
150 ident: self.ident.clone(),
151 colon_token: self.colon_token.clone(),
152 ty: self.ty.clone(),
153 eq_token: self.eq_token.clone(),
154 default: self.default.clone(),
159 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
161 fn clone(&self) -> Self {
163 ident: self.ident.clone(),
164 generics: self.generics.clone(),
165 colon_token: self.colon_token.clone(),
166 bounds: self.bounds.clone(),
171 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
173 fn clone(&self) -> Self {
175 Data::Struct(v0) => Data::Struct(v0.clone()),
176 Data::Enum(v0) => Data::Enum(v0.clone()),
177 Data::Union(v0) => Data::Union(v0.clone()),
182 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
184 fn clone(&self) -> Self {
186 enum_token: self.enum_token.clone(),
187 brace_token: self.brace_token.clone(),
188 variants: self.variants.clone(),
193 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
195 fn clone(&self) -> Self {
197 struct_token: self.struct_token.clone(),
198 fields: self.fields.clone(),
199 semi_token: self.semi_token.clone(),
204 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
206 fn clone(&self) -> Self {
208 union_token: self.union_token.clone(),
209 fields: self.fields.clone(),
214 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
216 fn clone(&self) -> Self {
218 attrs: self.attrs.clone(),
219 vis: self.vis.clone(),
220 ident: self.ident.clone(),
221 generics: self.generics.clone(),
222 data: self.data.clone(),
227 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
229 fn clone(&self) -> Self {
232 Expr::Array(v0) => Expr::Array(v0.clone()),
234 Expr::Assign(v0) => Expr::Assign(v0.clone()),
236 Expr::Async(v0) => Expr::Async(v0.clone()),
238 Expr::Await(v0) => Expr::Await(v0.clone()),
239 Expr::Binary(v0) => Expr::Binary(v0.clone()),
241 Expr::Block(v0) => Expr::Block(v0.clone()),
243 Expr::Break(v0) => Expr::Break(v0.clone()),
244 Expr::Call(v0) => Expr::Call(v0.clone()),
245 Expr::Cast(v0) => Expr::Cast(v0.clone()),
247 Expr::Closure(v0) => Expr::Closure(v0.clone()),
249 Expr::Const(v0) => Expr::Const(v0.clone()),
251 Expr::Continue(v0) => Expr::Continue(v0.clone()),
252 Expr::Field(v0) => Expr::Field(v0.clone()),
254 Expr::ForLoop(v0) => Expr::ForLoop(v0.clone()),
255 Expr::Group(v0) => Expr::Group(v0.clone()),
257 Expr::If(v0) => Expr::If(v0.clone()),
258 Expr::Index(v0) => Expr::Index(v0.clone()),
260 Expr::Infer(v0) => Expr::Infer(v0.clone()),
262 Expr::Let(v0) => Expr::Let(v0.clone()),
263 Expr::Lit(v0) => Expr::Lit(v0.clone()),
265 Expr::Loop(v0) => Expr::Loop(v0.clone()),
266 Expr::Macro(v0) => Expr::Macro(v0.clone()),
268 Expr::Match(v0) => Expr::Match(v0.clone()),
269 Expr::MethodCall(v0) => Expr::MethodCall(v0.clone()),
270 Expr::Paren(v0) => Expr::Paren(v0.clone()),
271 Expr::Path(v0) => Expr::Path(v0.clone()),
273 Expr::Range(v0) => Expr::Range(v0.clone()),
274 Expr::Reference(v0) => Expr::Reference(v0.clone()),
276 Expr::Repeat(v0) => Expr::Repeat(v0.clone()),
278 Expr::Return(v0) => Expr::Return(v0.clone()),
279 Expr::Struct(v0) => Expr::Struct(v0.clone()),
281 Expr::Try(v0) => Expr::Try(v0.clone()),
283 Expr::TryBlock(v0) => Expr::TryBlock(v0.clone()),
285 Expr::Tuple(v0) => Expr::Tuple(v0.clone()),
286 Expr::Unary(v0) => Expr::Unary(v0.clone()),
288 Expr::Unsafe(v0) => Expr::Unsafe(v0.clone()),
289 Expr::Verbatim(v0) => Expr::Verbatim(v0.clone()),
291 Expr::While(v0) => Expr::While(v0.clone()),
293 Expr::Yield(v0) => Expr::Yield(v0.clone()),
300 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
302 fn clone(&self) -> Self {
304 attrs: self.attrs.clone(),
305 bracket_token: self.bracket_token.clone(),
306 elems: self.elems.clone(),
311 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
313 fn clone(&self) -> Self {
315 attrs: self.attrs.clone(),
316 left: self.left.clone(),
317 eq_token: self.eq_token.clone(),
318 right: self.right.clone(),
323 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
325 fn clone(&self) -> Self {
327 attrs: self.attrs.clone(),
328 async_token: self.async_token.clone(),
329 capture: self.capture.clone(),
330 block: self.block.clone(),
335 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
337 fn clone(&self) -> Self {
339 attrs: self.attrs.clone(),
340 base: self.base.clone(),
341 dot_token: self.dot_token.clone(),
342 await_token: self.await_token.clone(),
347 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
349 fn clone(&self) -> Self {
351 attrs: self.attrs.clone(),
352 left: self.left.clone(),
353 op: self.op.clone(),
354 right: self.right.clone(),
359 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
361 fn clone(&self) -> Self {
363 attrs: self.attrs.clone(),
364 label: self.label.clone(),
365 block: self.block.clone(),
370 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
372 fn clone(&self) -> Self {
374 attrs: self.attrs.clone(),
375 break_token: self.break_token.clone(),
376 label: self.label.clone(),
377 expr: self.expr.clone(),
382 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
384 fn clone(&self) -> Self {
386 attrs: self.attrs.clone(),
387 func: self.func.clone(),
388 paren_token: self.paren_token.clone(),
389 args: self.args.clone(),
394 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
396 fn clone(&self) -> Self {
398 attrs: self.attrs.clone(),
399 expr: self.expr.clone(),
400 as_token: self.as_token.clone(),
401 ty: self.ty.clone(),
406 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
408 fn clone(&self) -> Self {
410 attrs: self.attrs.clone(),
411 lifetimes: self.lifetimes.clone(),
412 constness: self.constness.clone(),
413 movability: self.movability.clone(),
414 asyncness: self.asyncness.clone(),
415 capture: self.capture.clone(),
416 or1_token: self.or1_token.clone(),
417 inputs: self.inputs.clone(),
418 or2_token: self.or2_token.clone(),
419 output: self.output.clone(),
420 body: self.body.clone(),
425 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
427 fn clone(&self) -> Self {
429 attrs: self.attrs.clone(),
430 const_token: self.const_token.clone(),
431 block: self.block.clone(),
436 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
438 fn clone(&self) -> Self {
440 attrs: self.attrs.clone(),
441 continue_token: self.continue_token.clone(),
442 label: self.label.clone(),
447 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
449 fn clone(&self) -> Self {
451 attrs: self.attrs.clone(),
452 base: self.base.clone(),
453 dot_token: self.dot_token.clone(),
454 member: self.member.clone(),
459 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
461 fn clone(&self) -> Self {
463 attrs: self.attrs.clone(),
464 label: self.label.clone(),
465 for_token: self.for_token.clone(),
466 pat: self.pat.clone(),
467 in_token: self.in_token.clone(),
468 expr: self.expr.clone(),
469 body: self.body.clone(),
474 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
476 fn clone(&self) -> Self {
478 attrs: self.attrs.clone(),
479 group_token: self.group_token.clone(),
480 expr: self.expr.clone(),
485 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
487 fn clone(&self) -> Self {
489 attrs: self.attrs.clone(),
490 if_token: self.if_token.clone(),
491 cond: self.cond.clone(),
492 then_branch: self.then_branch.clone(),
493 else_branch: self.else_branch.clone(),
498 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
500 fn clone(&self) -> Self {
502 attrs: self.attrs.clone(),
503 expr: self.expr.clone(),
504 bracket_token: self.bracket_token.clone(),
505 index: self.index.clone(),
510 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
512 fn clone(&self) -> Self {
514 attrs: self.attrs.clone(),
515 underscore_token: self.underscore_token.clone(),
520 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
522 fn clone(&self) -> Self {
524 attrs: self.attrs.clone(),
525 let_token: self.let_token.clone(),
526 pat: self.pat.clone(),
527 eq_token: self.eq_token.clone(),
528 expr: self.expr.clone(),
533 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
535 fn clone(&self) -> Self {
537 attrs: self.attrs.clone(),
538 lit: self.lit.clone(),
543 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
545 fn clone(&self) -> Self {
547 attrs: self.attrs.clone(),
548 label: self.label.clone(),
549 loop_token: self.loop_token.clone(),
550 body: self.body.clone(),
555 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
557 fn clone(&self) -> Self {
559 attrs: self.attrs.clone(),
560 mac: self.mac.clone(),
565 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
567 fn clone(&self) -> Self {
569 attrs: self.attrs.clone(),
570 match_token: self.match_token.clone(),
571 expr: self.expr.clone(),
572 brace_token: self.brace_token.clone(),
573 arms: self.arms.clone(),
578 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
580 fn clone(&self) -> Self {
582 attrs: self.attrs.clone(),
583 receiver: self.receiver.clone(),
584 dot_token: self.dot_token.clone(),
585 method: self.method.clone(),
586 turbofish: self.turbofish.clone(),
587 paren_token: self.paren_token.clone(),
588 args: self.args.clone(),
593 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
595 fn clone(&self) -> Self {
597 attrs: self.attrs.clone(),
598 paren_token: self.paren_token.clone(),
599 expr: self.expr.clone(),
604 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
606 fn clone(&self) -> Self {
608 attrs: self.attrs.clone(),
609 qself: self.qself.clone(),
610 path: self.path.clone(),
615 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
617 fn clone(&self) -> Self {
619 attrs: self.attrs.clone(),
620 start: self.start.clone(),
621 limits: self.limits.clone(),
622 end: self.end.clone(),
627 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
629 fn clone(&self) -> Self {
631 attrs: self.attrs.clone(),
632 and_token: self.and_token.clone(),
633 mutability: self.mutability.clone(),
634 expr: self.expr.clone(),
639 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
641 fn clone(&self) -> Self {
643 attrs: self.attrs.clone(),
644 bracket_token: self.bracket_token.clone(),
645 expr: self.expr.clone(),
646 semi_token: self.semi_token.clone(),
647 len: self.len.clone(),
652 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
654 fn clone(&self) -> Self {
656 attrs: self.attrs.clone(),
657 return_token: self.return_token.clone(),
658 expr: self.expr.clone(),
663 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
665 fn clone(&self) -> Self {
667 attrs: self.attrs.clone(),
668 qself: self.qself.clone(),
669 path: self.path.clone(),
670 brace_token: self.brace_token.clone(),
671 fields: self.fields.clone(),
672 dot2_token: self.dot2_token.clone(),
673 rest: self.rest.clone(),
678 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
680 fn clone(&self) -> Self {
682 attrs: self.attrs.clone(),
683 expr: self.expr.clone(),
684 question_token: self.question_token.clone(),
689 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
691 fn clone(&self) -> Self {
693 attrs: self.attrs.clone(),
694 try_token: self.try_token.clone(),
695 block: self.block.clone(),
700 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
702 fn clone(&self) -> Self {
704 attrs: self.attrs.clone(),
705 paren_token: self.paren_token.clone(),
706 elems: self.elems.clone(),
711 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
713 fn clone(&self) -> Self {
715 attrs: self.attrs.clone(),
716 op: self.op.clone(),
717 expr: self.expr.clone(),
722 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
724 fn clone(&self) -> Self {
726 attrs: self.attrs.clone(),
727 unsafe_token: self.unsafe_token.clone(),
728 block: self.block.clone(),
733 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
735 fn clone(&self) -> Self {
737 attrs: self.attrs.clone(),
738 label: self.label.clone(),
739 while_token: self.while_token.clone(),
740 cond: self.cond.clone(),
741 body: self.body.clone(),
746 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
748 fn clone(&self) -> Self {
750 attrs: self.attrs.clone(),
751 yield_token: self.yield_token.clone(),
752 expr: self.expr.clone(),
757 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
759 fn clone(&self) -> Self {
761 attrs: self.attrs.clone(),
762 vis: self.vis.clone(),
763 mutability: self.mutability.clone(),
764 ident: self.ident.clone(),
765 colon_token: self.colon_token.clone(),
766 ty: self.ty.clone(),
771 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
773 fn clone(&self) -> Self {
780 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
782 fn clone(&self) -> Self {
784 attrs: self.attrs.clone(),
785 member: self.member.clone(),
786 colon_token: self.colon_token.clone(),
787 pat: self.pat.clone(),
792 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
794 fn clone(&self) -> Self {
796 attrs: self.attrs.clone(),
797 member: self.member.clone(),
798 colon_token: self.colon_token.clone(),
799 expr: self.expr.clone(),
804 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
806 fn clone(&self) -> Self {
808 Fields::Named(v0) => Fields::Named(v0.clone()),
809 Fields::Unnamed(v0) => Fields::Unnamed(v0.clone()),
815 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
817 fn clone(&self) -> Self {
819 brace_token: self.brace_token.clone(),
820 named: self.named.clone(),
825 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
827 fn clone(&self) -> Self {
829 paren_token: self.paren_token.clone(),
830 unnamed: self.unnamed.clone(),
835 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
837 fn clone(&self) -> Self {
839 shebang: self.shebang.clone(),
840 attrs: self.attrs.clone(),
841 items: self.items.clone(),
846 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
848 fn clone(&self) -> Self {
850 FnArg::Receiver(v0) => FnArg::Receiver(v0.clone()),
851 FnArg::Typed(v0) => FnArg::Typed(v0.clone()),
856 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
858 fn clone(&self) -> Self {
860 ForeignItem::Fn(v0) => ForeignItem::Fn(v0.clone()),
861 ForeignItem::Static(v0) => ForeignItem::Static(v0.clone()),
862 ForeignItem::Type(v0) => ForeignItem::Type(v0.clone()),
863 ForeignItem::Macro(v0) => ForeignItem::Macro(v0.clone()),
864 ForeignItem::Verbatim(v0) => ForeignItem::Verbatim(v0.clone()),
869 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
871 fn clone(&self) -> Self {
873 attrs: self.attrs.clone(),
874 vis: self.vis.clone(),
875 sig: self.sig.clone(),
876 semi_token: self.semi_token.clone(),
881 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
883 fn clone(&self) -> Self {
885 attrs: self.attrs.clone(),
886 mac: self.mac.clone(),
887 semi_token: self.semi_token.clone(),
892 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
894 fn clone(&self) -> Self {
896 attrs: self.attrs.clone(),
897 vis: self.vis.clone(),
898 static_token: self.static_token.clone(),
899 mutability: self.mutability.clone(),
900 ident: self.ident.clone(),
901 colon_token: self.colon_token.clone(),
902 ty: self.ty.clone(),
903 semi_token: self.semi_token.clone(),
908 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
910 fn clone(&self) -> Self {
912 attrs: self.attrs.clone(),
913 vis: self.vis.clone(),
914 type_token: self.type_token.clone(),
915 ident: self.ident.clone(),
916 generics: self.generics.clone(),
917 semi_token: self.semi_token.clone(),
922 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
924 fn clone(&self) -> Self {
926 GenericArgument::Lifetime(v0) => GenericArgument::Lifetime(v0.clone()),
927 GenericArgument::Type(v0) => GenericArgument::Type(v0.clone()),
928 GenericArgument::Const(v0) => GenericArgument::Const(v0.clone()),
929 GenericArgument::AssocType(v0) => GenericArgument::AssocType(v0.clone()),
930 GenericArgument::AssocConst(v0) => GenericArgument::AssocConst(v0.clone()),
931 GenericArgument::Constraint(v0) => GenericArgument::Constraint(v0.clone()),
936 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
938 fn clone(&self) -> Self {
940 GenericParam::Lifetime(v0) => GenericParam::Lifetime(v0.clone()),
941 GenericParam::Type(v0) => GenericParam::Type(v0.clone()),
942 GenericParam::Const(v0) => GenericParam::Const(v0.clone()),
947 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
949 fn clone(&self) -> Self {
951 lt_token: self.lt_token.clone(),
952 params: self.params.clone(),
953 gt_token: self.gt_token.clone(),
954 where_clause: self.where_clause.clone(),
959 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
961 fn clone(&self) -> Self {
963 ImplItem::Const(v0) => ImplItem::Const(v0.clone()),
964 ImplItem::Fn(v0) => ImplItem::Fn(v0.clone()),
965 ImplItem::Type(v0) => ImplItem::Type(v0.clone()),
966 ImplItem::Macro(v0) => ImplItem::Macro(v0.clone()),
967 ImplItem::Verbatim(v0) => ImplItem::Verbatim(v0.clone()),
972 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
974 fn clone(&self) -> Self {
976 attrs: self.attrs.clone(),
977 vis: self.vis.clone(),
978 defaultness: self.defaultness.clone(),
979 const_token: self.const_token.clone(),
980 ident: self.ident.clone(),
981 generics: self.generics.clone(),
982 colon_token: self.colon_token.clone(),
983 ty: self.ty.clone(),
984 eq_token: self.eq_token.clone(),
985 expr: self.expr.clone(),
986 semi_token: self.semi_token.clone(),
991 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
993 fn clone(&self) -> Self {
995 attrs: self.attrs.clone(),
996 vis: self.vis.clone(),
997 defaultness: self.defaultness.clone(),
998 sig: self.sig.clone(),
999 block: self.block.clone(),
1004 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1006 fn clone(&self) -> Self {
1008 attrs: self.attrs.clone(),
1009 mac: self.mac.clone(),
1010 semi_token: self.semi_token.clone(),
1015 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1017 fn clone(&self) -> Self {
1019 attrs: self.attrs.clone(),
1020 vis: self.vis.clone(),
1021 defaultness: self.defaultness.clone(),
1022 type_token: self.type_token.clone(),
1023 ident: self.ident.clone(),
1024 generics: self.generics.clone(),
1025 eq_token: self.eq_token.clone(),
1026 ty: self.ty.clone(),
1027 semi_token: self.semi_token.clone(),
1032 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1034 fn clone(&self) -> Self {
1039 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1041 fn clone(&self) -> Self {
1043 index: self.index.clone(),
1044 span: self.span.clone(),
1049 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1051 fn clone(&self) -> Self {
1053 Item::Const(v0) => Item::Const(v0.clone()),
1054 Item::Enum(v0) => Item::Enum(v0.clone()),
1055 Item::ExternCrate(v0) => Item::ExternCrate(v0.clone()),
1056 Item::Fn(v0) => Item::Fn(v0.clone()),
1057 Item::ForeignMod(v0) => Item::ForeignMod(v0.clone()),
1058 Item::Impl(v0) => Item::Impl(v0.clone()),
1059 Item::Macro(v0) => Item::Macro(v0.clone()),
1060 Item::Mod(v0) => Item::Mod(v0.clone()),
1061 Item::Static(v0) => Item::Static(v0.clone()),
1062 Item::Struct(v0) => Item::Struct(v0.clone()),
1063 Item::Trait(v0) => Item::Trait(v0.clone()),
1064 Item::TraitAlias(v0) => Item::TraitAlias(v0.clone()),
1065 Item::Type(v0) => Item::Type(v0.clone()),
1066 Item::Union(v0) => Item::Union(v0.clone()),
1067 Item::Use(v0) => Item::Use(v0.clone()),
1068 Item::Verbatim(v0) => Item::Verbatim(v0.clone()),
1073 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1075 fn clone(&self) -> Self {
1077 attrs: self.attrs.clone(),
1078 vis: self.vis.clone(),
1079 const_token: self.const_token.clone(),
1080 ident: self.ident.clone(),
1081 generics: self.generics.clone(),
1082 colon_token: self.colon_token.clone(),
1083 ty: self.ty.clone(),
1084 eq_token: self.eq_token.clone(),
1085 expr: self.expr.clone(),
1086 semi_token: self.semi_token.clone(),
1091 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1093 fn clone(&self) -> Self {
1095 attrs: self.attrs.clone(),
1096 vis: self.vis.clone(),
1097 enum_token: self.enum_token.clone(),
1098 ident: self.ident.clone(),
1099 generics: self.generics.clone(),
1100 brace_token: self.brace_token.clone(),
1101 variants: self.variants.clone(),
1106 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1108 fn clone(&self) -> Self {
1110 attrs: self.attrs.clone(),
1111 vis: self.vis.clone(),
1112 extern_token: self.extern_token.clone(),
1113 crate_token: self.crate_token.clone(),
1114 ident: self.ident.clone(),
1115 rename: self.rename.clone(),
1116 semi_token: self.semi_token.clone(),
1121 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1123 fn clone(&self) -> Self {
1125 attrs: self.attrs.clone(),
1126 vis: self.vis.clone(),
1127 sig: self.sig.clone(),
1128 block: self.block.clone(),
1133 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1135 fn clone(&self) -> Self {
1137 attrs: self.attrs.clone(),
1138 unsafety: self.unsafety.clone(),
1139 abi: self.abi.clone(),
1140 brace_token: self.brace_token.clone(),
1141 items: self.items.clone(),
1146 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1148 fn clone(&self) -> Self {
1150 attrs: self.attrs.clone(),
1151 defaultness: self.defaultness.clone(),
1152 unsafety: self.unsafety.clone(),
1153 impl_token: self.impl_token.clone(),
1154 generics: self.generics.clone(),
1155 trait_: self.trait_.clone(),
1156 self_ty: self.self_ty.clone(),
1157 brace_token: self.brace_token.clone(),
1158 items: self.items.clone(),
1163 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1165 fn clone(&self) -> Self {
1167 attrs: self.attrs.clone(),
1168 ident: self.ident.clone(),
1169 mac: self.mac.clone(),
1170 semi_token: self.semi_token.clone(),
1175 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1177 fn clone(&self) -> Self {
1179 attrs: self.attrs.clone(),
1180 vis: self.vis.clone(),
1181 unsafety: self.unsafety.clone(),
1182 mod_token: self.mod_token.clone(),
1183 ident: self.ident.clone(),
1184 content: self.content.clone(),
1185 semi: self.semi.clone(),
1190 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1192 fn clone(&self) -> Self {
1194 attrs: self.attrs.clone(),
1195 vis: self.vis.clone(),
1196 static_token: self.static_token.clone(),
1197 mutability: self.mutability.clone(),
1198 ident: self.ident.clone(),
1199 colon_token: self.colon_token.clone(),
1200 ty: self.ty.clone(),
1201 eq_token: self.eq_token.clone(),
1202 expr: self.expr.clone(),
1203 semi_token: self.semi_token.clone(),
1208 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1210 fn clone(&self) -> Self {
1212 attrs: self.attrs.clone(),
1213 vis: self.vis.clone(),
1214 struct_token: self.struct_token.clone(),
1215 ident: self.ident.clone(),
1216 generics: self.generics.clone(),
1217 fields: self.fields.clone(),
1218 semi_token: self.semi_token.clone(),
1223 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1225 fn clone(&self) -> Self {
1227 attrs: self.attrs.clone(),
1228 vis: self.vis.clone(),
1229 unsafety: self.unsafety.clone(),
1230 auto_token: self.auto_token.clone(),
1231 restriction: self.restriction.clone(),
1232 trait_token: self.trait_token.clone(),
1233 ident: self.ident.clone(),
1234 generics: self.generics.clone(),
1235 colon_token: self.colon_token.clone(),
1236 supertraits: self.supertraits.clone(),
1237 brace_token: self.brace_token.clone(),
1238 items: self.items.clone(),
1243 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1245 fn clone(&self) -> Self {
1247 attrs: self.attrs.clone(),
1248 vis: self.vis.clone(),
1249 trait_token: self.trait_token.clone(),
1250 ident: self.ident.clone(),
1251 generics: self.generics.clone(),
1252 eq_token: self.eq_token.clone(),
1253 bounds: self.bounds.clone(),
1254 semi_token: self.semi_token.clone(),
1259 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1261 fn clone(&self) -> Self {
1263 attrs: self.attrs.clone(),
1264 vis: self.vis.clone(),
1265 type_token: self.type_token.clone(),
1266 ident: self.ident.clone(),
1267 generics: self.generics.clone(),
1268 eq_token: self.eq_token.clone(),
1269 ty: self.ty.clone(),
1270 semi_token: self.semi_token.clone(),
1275 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1277 fn clone(&self) -> Self {
1279 attrs: self.attrs.clone(),
1280 vis: self.vis.clone(),
1281 union_token: self.union_token.clone(),
1282 ident: self.ident.clone(),
1283 generics: self.generics.clone(),
1284 fields: self.fields.clone(),
1289 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1291 fn clone(&self) -> Self {
1293 attrs: self.attrs.clone(),
1294 vis: self.vis.clone(),
1295 use_token: self.use_token.clone(),
1296 leading_colon: self.leading_colon.clone(),
1297 tree: self.tree.clone(),
1298 semi_token: self.semi_token.clone(),
1303 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1305 fn clone(&self) -> Self {
1307 name: self.name.clone(),
1308 colon_token: self.colon_token.clone(),
1313 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1315 fn clone(&self) -> Self {
1317 attrs: self.attrs.clone(),
1318 lifetime: self.lifetime.clone(),
1319 colon_token: self.colon_token.clone(),
1320 bounds: self.bounds.clone(),
1324 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1326 fn clone(&self) -> Self {
1328 Lit::Str(v0) => Lit::Str(v0.clone()),
1329 Lit::ByteStr(v0) => Lit::ByteStr(v0.clone()),
1330 Lit::Byte(v0) => Lit::Byte(v0.clone()),
1331 Lit::Char(v0) => Lit::Char(v0.clone()),
1332 Lit::Int(v0) => Lit::Int(v0.clone()),
1333 Lit::Float(v0) => Lit::Float(v0.clone()),
1334 Lit::Bool(v0) => Lit::Bool(v0.clone()),
1335 Lit::Verbatim(v0) => Lit::Verbatim(v0.clone()),
1339 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1341 fn clone(&self) -> Self {
1343 value: self.value.clone(),
1344 span: self.span.clone(),
1349 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1351 fn clone(&self) -> Self {
1353 attrs: self.attrs.clone(),
1354 let_token: self.let_token.clone(),
1355 pat: self.pat.clone(),
1356 init: self.init.clone(),
1357 semi_token: self.semi_token.clone(),
1362 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1364 fn clone(&self) -> Self {
1366 eq_token: self.eq_token.clone(),
1367 expr: self.expr.clone(),
1368 diverge: self.diverge.clone(),
1373 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1375 fn clone(&self) -> Self {
1377 path: self.path.clone(),
1378 bang_token: self.bang_token.clone(),
1379 delimiter: self.delimiter.clone(),
1380 tokens: self.tokens.clone(),
1385 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1387 fn clone(&self) -> Self {
1389 MacroDelimiter::Paren(v0) => MacroDelimiter::Paren(v0.clone()),
1390 MacroDelimiter::Brace(v0) => MacroDelimiter::Brace(v0.clone()),
1391 MacroDelimiter::Bracket(v0) => MacroDelimiter::Bracket(v0.clone()),
1396 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1398 fn clone(&self) -> Self {
1400 Member::Named(v0) => Member::Named(v0.clone()),
1401 Member::Unnamed(v0) => Member::Unnamed(v0.clone()),
1406 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1408 fn clone(&self) -> Self {
1410 Meta::Path(v0) => Meta::Path(v0.clone()),
1411 Meta::List(v0) => Meta::List(v0.clone()),
1412 Meta::NameValue(v0) => Meta::NameValue(v0.clone()),
1417 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1419 fn clone(&self) -> Self {
1421 path: self.path.clone(),
1422 delimiter: self.delimiter.clone(),
1423 tokens: self.tokens.clone(),
1428 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1430 fn clone(&self) -> Self {
1432 path: self.path.clone(),
1433 eq_token: self.eq_token.clone(),
1434 value: self.value.clone(),
1439 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1441 fn clone(&self) -> Self {
1443 paren_token: self.paren_token.clone(),
1444 inputs: self.inputs.clone(),
1445 output: self.output.clone(),
1450 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1452 fn clone(&self) -> Self {
1454 Pat::Const(v0) => Pat::Const(v0.clone()),
1455 Pat::Ident(v0) => Pat::Ident(v0.clone()),
1456 Pat::Lit(v0) => Pat::Lit(v0.clone()),
1457 Pat::Macro(v0) => Pat::Macro(v0.clone()),
1458 Pat::Or(v0) => Pat::Or(v0.clone()),
1459 Pat::Paren(v0) => Pat::Paren(v0.clone()),
1460 Pat::Path(v0) => Pat::Path(v0.clone()),
1461 Pat::Range(v0) => Pat::Range(v0.clone()),
1462 Pat::Reference(v0) => Pat::Reference(v0.clone()),
1463 Pat::Rest(v0) => Pat::Rest(v0.clone()),
1464 Pat::Slice(v0) => Pat::Slice(v0.clone()),
1465 Pat::Struct(v0) => Pat::Struct(v0.clone()),
1466 Pat::Tuple(v0) => Pat::Tuple(v0.clone()),
1467 Pat::TupleStruct(v0) => Pat::TupleStruct(v0.clone()),
1468 Pat::Type(v0) => Pat::Type(v0.clone()),
1469 Pat::Verbatim(v0) => Pat::Verbatim(v0.clone()),
1470 Pat::Wild(v0) => Pat::Wild(v0.clone()),
1475 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1477 fn clone(&self) -> Self {
1479 attrs: self.attrs.clone(),
1480 by_ref: self.by_ref.clone(),
1481 mutability: self.mutability.clone(),
1482 ident: self.ident.clone(),
1483 subpat: self.subpat.clone(),
1488 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1490 fn clone(&self) -> Self {
1492 attrs: self.attrs.clone(),
1493 leading_vert: self.leading_vert.clone(),
1494 cases: self.cases.clone(),
1499 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1501 fn clone(&self) -> Self {
1503 attrs: self.attrs.clone(),
1504 paren_token: self.paren_token.clone(),
1505 pat: self.pat.clone(),
1510 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1512 fn clone(&self) -> Self {
1514 attrs: self.attrs.clone(),
1515 and_token: self.and_token.clone(),
1516 mutability: self.mutability.clone(),
1517 pat: self.pat.clone(),
1522 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1524 fn clone(&self) -> Self {
1526 attrs: self.attrs.clone(),
1527 dot2_token: self.dot2_token.clone(),
1532 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1534 fn clone(&self) -> Self {
1536 attrs: self.attrs.clone(),
1537 bracket_token: self.bracket_token.clone(),
1538 elems: self.elems.clone(),
1543 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1545 fn clone(&self) -> Self {
1547 attrs: self.attrs.clone(),
1548 qself: self.qself.clone(),
1549 path: self.path.clone(),
1550 brace_token: self.brace_token.clone(),
1551 fields: self.fields.clone(),
1552 rest: self.rest.clone(),
1557 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1559 fn clone(&self) -> Self {
1561 attrs: self.attrs.clone(),
1562 paren_token: self.paren_token.clone(),
1563 elems: self.elems.clone(),
1568 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1570 fn clone(&self) -> Self {
1572 attrs: self.attrs.clone(),
1573 qself: self.qself.clone(),
1574 path: self.path.clone(),
1575 paren_token: self.paren_token.clone(),
1576 elems: self.elems.clone(),
1581 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1583 fn clone(&self) -> Self {
1585 attrs: self.attrs.clone(),
1586 pat: self.pat.clone(),
1587 colon_token: self.colon_token.clone(),
1588 ty: self.ty.clone(),
1593 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1595 fn clone(&self) -> Self {
1597 attrs: self.attrs.clone(),
1598 underscore_token: self.underscore_token.clone(),
1603 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1605 fn clone(&self) -> Self {
1607 leading_colon: self.leading_colon.clone(),
1608 segments: self.segments.clone(),
1613 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1615 fn clone(&self) -> Self {
1619 PathArguments::AngleBracketed(v0.clone())
1621 PathArguments::Parenthesized(v0) => PathArguments::Parenthesized(v0.clone()),
1626 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1628 fn clone(&self) -> Self {
1630 ident: self.ident.clone(),
1631 arguments: self.arguments.clone(),
1636 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1638 fn clone(&self) -> Self {
1640 lifetime: self.lifetime.clone(),
1641 colon_token: self.colon_token.clone(),
1642 bounds: self.bounds.clone(),
1647 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1649 fn clone(&self) -> Self {
1651 lifetimes: self.lifetimes.clone(),
1652 bounded_ty: self.bounded_ty.clone(),
1653 colon_token: self.colon_token.clone(),
1654 bounds: self.bounds.clone(),
1659 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1661 fn clone(&self) -> Self {
1663 lt_token: self.lt_token.clone(),
1664 ty: self.ty.clone(),
1665 position: self.position.clone(),
1666 as_token: self.as_token.clone(),
1667 gt_token: self.gt_token.clone(),
1672 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1675 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1677 fn clone(&self) -> Self {
1682 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1684 fn clone(&self) -> Self {
1686 attrs: self.attrs.clone(),
1687 reference: self.reference.clone(),
1688 mutability: self.mutability.clone(),
1689 self_token: self.self_token.clone(),
1690 colon_token: self.colon_token.clone(),
1691 ty: self.ty.clone(),
1696 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1698 fn clone(&self) -> Self {
1701 ReturnType::Type(v0, v1) => ReturnType::Type(v0.clone(), v1.clone()),
1706 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1708 fn clone(&self) -> Self {
1710 constness: self.constness.clone(),
1711 asyncness: self.asyncness.clone(),
1712 unsafety: self.unsafety.clone(),
1713 abi: self.abi.clone(),
1714 fn_token: self.fn_token.clone(),
1715 ident: self.ident.clone(),
1716 generics: self.generics.clone(),
1717 paren_token: self.paren_token.clone(),
1718 inputs: self.inputs.clone(),
1719 variadic: self.variadic.clone(),
1720 output: self.output.clone(),
1725 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1727 fn clone(&self) -> Self {
1729 StaticMutability::Mut(v0) => StaticMutability::Mut(v0.clone()),
1735 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1737 fn clone(&self) -> Self {
1739 Stmt::Local(v0) => Stmt::Local(v0.clone()),
1740 Stmt::Item(v0) => Stmt::Item(v0.clone()),
1741 Stmt::Expr(v0, v1) => Stmt::Expr(v0.clone(), v1.clone()),
1742 Stmt::Macro(v0) => Stmt::Macro(v0.clone()),
1747 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1749 fn clone(&self) -> Self {
1751 attrs: self.attrs.clone(),
1752 mac: self.mac.clone(),
1753 semi_token: self.semi_token.clone(),
1758 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1760 fn clone(&self) -> Self {
1762 paren_token: self.paren_token.clone(),
1763 modifier: self.modifier.clone(),
1764 lifetimes: self.lifetimes.clone(),
1765 path: self.path.clone(),
1770 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1773 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1775 fn clone(&self) -> Self {
1780 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1782 fn clone(&self) -> Self {
1784 TraitItem::Const(v0) => TraitItem::Const(v0.clone()),
1785 TraitItem::Fn(v0) => TraitItem::Fn(v0.clone()),
1786 TraitItem::Type(v0) => TraitItem::Type(v0.clone()),
1787 TraitItem::Macro(v0) => TraitItem::Macro(v0.clone()),
1788 TraitItem::Verbatim(v0) => TraitItem::Verbatim(v0.clone()),
1793 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1795 fn clone(&self) -> Self {
1797 attrs: self.attrs.clone(),
1798 const_token: self.const_token.clone(),
1799 ident: self.ident.clone(),
1800 generics: self.generics.clone(),
1801 colon_token: self.colon_token.clone(),
1802 ty: self.ty.clone(),
1803 default: self.default.clone(),
1804 semi_token: self.semi_token.clone(),
1809 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1811 fn clone(&self) -> Self {
1813 attrs: self.attrs.clone(),
1814 sig: self.sig.clone(),
1815 default: self.default.clone(),
1816 semi_token: self.semi_token.clone(),
1821 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1823 fn clone(&self) -> Self {
1825 attrs: self.attrs.clone(),
1826 mac: self.mac.clone(),
1827 semi_token: self.semi_token.clone(),
1832 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1834 fn clone(&self) -> Self {
1836 attrs: self.attrs.clone(),
1837 type_token: self.type_token.clone(),
1838 ident: self.ident.clone(),
1839 generics: self.generics.clone(),
1840 colon_token: self.colon_token.clone(),
1841 bounds: self.bounds.clone(),
1842 default: self.default.clone(),
1843 semi_token: self.semi_token.clone(),
1848 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1850 fn clone(&self) -> Self {
1852 Type::Array(v0) => Type::Array(v0.clone()),
1853 Type::BareFn(v0) => Type::BareFn(v0.clone()),
1854 Type::Group(v0) => Type::Group(v0.clone()),
1855 Type::ImplTrait(v0) => Type::ImplTrait(v0.clone()),
1856 Type::Infer(v0) => Type::Infer(v0.clone()),
1857 Type::Macro(v0) => Type::Macro(v0.clone()),
1858 Type::Never(v0) => Type::Never(v0.clone()),
1859 Type::Paren(v0) => Type::Paren(v0.clone()),
1860 Type::Path(v0) => Type::Path(v0.clone()),
1861 Type::Ptr(v0) => Type::Ptr(v0.clone()),
1862 Type::Reference(v0) => Type::Reference(v0.clone()),
1863 Type::Slice(v0) => Type::Slice(v0.clone()),
1864 Type::TraitObject(v0) => Type::TraitObject(v0.clone()),
1865 Type::Tuple(v0) => Type::Tuple(v0.clone()),
1866 Type::Verbatim(v0) => Type::Verbatim(v0.clone()),
1871 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1873 fn clone(&self) -> Self {
1875 bracket_token: self.bracket_token.clone(),
1876 elem: self.elem.clone(),
1877 semi_token: self.semi_token.clone(),
1878 len: self.len.clone(),
1883 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1885 fn clone(&self) -> Self {
1887 lifetimes: self.lifetimes.clone(),
1888 unsafety: self.unsafety.clone(),
1889 abi: self.abi.clone(),
1890 fn_token: self.fn_token.clone(),
1891 paren_token: self.paren_token.clone(),
1892 inputs: self.inputs.clone(),
1893 variadic: self.variadic.clone(),
1894 output: self.output.clone(),
1899 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1901 fn clone(&self) -> Self {
1903 group_token: self.group_token.clone(),
1904 elem: self.elem.clone(),
1909 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1911 fn clone(&self) -> Self {
1913 impl_token: self.impl_token.clone(),
1914 bounds: self.bounds.clone(),
1919 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1921 fn clone(&self) -> Self {
1923 underscore_token: self.underscore_token.clone(),
1928 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1930 fn clone(&self) -> Self {
1931 TypeMacro { mac: self.mac.clone() }
1935 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1937 fn clone(&self) -> Self {
1939 bang_token: self.bang_token.clone(),
1944 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1946 fn clone(&self) -> Self {
1948 attrs: self.attrs.clone(),
1949 ident: self.ident.clone(),
1950 colon_token: self.colon_token.clone(),
1951 bounds: self.bounds.clone(),
1952 eq_token: self.eq_token.clone(),
1953 default: self.default.clone(),
1958 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1960 fn clone(&self) -> Self {
1962 TypeParamBound::Trait(v0) => TypeParamBound::Trait(v0.clone()),
1963 TypeParamBound::Lifetime(v0) => TypeParamBound::Lifetime(v0.clone()),
1964 TypeParamBound::Verbatim(v0) => TypeParamBound::Verbatim(v0.clone()),
1969 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1971 fn clone(&self) -> Self {
1973 paren_token: self.paren_token.clone(),
1974 elem: self.elem.clone(),
1979 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1981 fn clone(&self) -> Self {
1983 qself: self.qself.clone(),
1984 path: self.path.clone(),
1989 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1991 fn clone(&self) -> Self {
1993 star_token: self.star_token.clone(),
1994 const_token: self.const_token.clone(),
1995 mutability: self.mutability.clone(),
1996 elem: self.elem.clone(),
2001 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2003 fn clone(&self) -> Self {
2005 and_token: self.and_token.clone(),
2006 lifetime: self.lifetime.clone(),
2007 mutability: self.mutability.clone(),
2008 elem: self.elem.clone(),
2013 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2015 fn clone(&self) -> Self {
2017 bracket_token: self.bracket_token.clone(),
2018 elem: self.elem.clone(),
2023 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2025 fn clone(&self) -> Self {
2027 dyn_token: self.dyn_token.clone(),
2028 bounds: self.bounds.clone(),
2033 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2035 fn clone(&self) -> Self {
2037 paren_token: self.paren_token.clone(),
2038 elems: self.elems.clone(),
2043 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2046 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2048 fn clone(&self) -> Self {
2053 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2055 fn clone(&self) -> Self {
2057 star_token: self.star_token.clone(),
2062 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2064 fn clone(&self) -> Self {
2066 brace_token: self.brace_token.clone(),
2067 items: self.items.clone(),
2072 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2074 fn clone(&self) -> Self {
2076 ident: self.ident.clone(),
2081 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2083 fn clone(&self) -> Self {
2085 ident: self.ident.clone(),
2086 colon2_token: self.colon2_token.clone(),
2087 tree: self.tree.clone(),
2092 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2094 fn clone(&self) -> Self {
2096 ident: self.ident.clone(),
2097 as_token: self.as_token.clone(),
2098 rename: self.rename.clone(),
2103 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2105 fn clone(&self) -> Self {
2107 UseTree::Path(v0) => UseTree::Path(v0.clone()),
2108 UseTree::Name(v0) => UseTree::Name(v0.clone()),
2109 UseTree::Rename(v0) => UseTree::Rename(v0.clone()),
2110 UseTree::Glob(v0) => UseTree::Glob(v0.clone()),
2111 UseTree::Group(v0) => UseTree::Group(v0.clone()),
2116 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2118 fn clone(&self) -> Self {
2120 attrs: self.attrs.clone(),
2121 pat: self.pat.clone(),
2122 dots: self.dots.clone(),
2123 comma: self.comma.clone(),
2128 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2130 fn clone(&self) -> Self {
2132 attrs: self.attrs.clone(),
2133 ident: self.ident.clone(),
2134 fields: self.fields.clone(),
2135 discriminant: self.discriminant.clone(),
2140 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2142 fn clone(&self) -> Self {
2144 pub_token: self.pub_token.clone(),
2145 paren_token: self.paren_token.clone(),
2146 in_token: self.in_token.clone(),
2147 path: self.path.clone(),
2152 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2154 fn clone(&self) -> Self {
2156 Visibility::Public(v0) => Visibility::Public(v0.clone()),
2157 Visibility::Restricted(v0) => Visibility::Restricted(v0.clone()),
2163 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2165 fn clone(&self) -> Self {
2167 where_token: self.where_token.clone(),
2168 predicates: self.predicates.clone(),
2173 #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2175 fn clone(&self) -> Self {
2177 WherePredicate::Lifetime(v0) => WherePredicate::Lifetime(v0.clone()),
2178 WherePredicate::Type(v0) => WherePredicate::Type(v0.clone()),