1// This file is @generated by syn-internal-codegen.
2// It is not intended for manual editing.
3
4#![allow(clippy::clone_on_copy, clippy::expl_impl_clone_on_copy)]
5#[cfg(any(feature = "derive", feature = "full"))]
6#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
7impl Clone for crate::Abi {
8 fn clone(&self) -> Self {
9 crate::Abi {
10 extern_token: self.extern_token.clone(),
11 name: self.name.clone(),
12 }
13 }
14}
15#[cfg(any(feature = "derive", feature = "full"))]
16#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
17impl Clone for crate::AngleBracketedGenericArguments {
18 fn clone(&self) -> Self {
19 crate::AngleBracketedGenericArguments {
20 colon2_token: self.colon2_token.clone(),
21 lt_token: self.lt_token.clone(),
22 args: self.args.clone(),
23 gt_token: self.gt_token.clone(),
24 }
25 }
26}
27#[cfg(feature = "full")]
28#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
29impl Clone for crate::Arm {
30 fn clone(&self) -> Self {
31 crate::Arm {
32 attrs: self.attrs.clone(),
33 pat: self.pat.clone(),
34 guard: self.guard.clone(),
35 fat_arrow_token: self.fat_arrow_token.clone(),
36 body: self.body.clone(),
37 comma: self.comma.clone(),
38 }
39 }
40}
41#[cfg(any(feature = "derive", feature = "full"))]
42#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
43impl Clone for crate::AssocConst {
44 fn clone(&self) -> Self {
45 crate::AssocConst {
46 ident: self.ident.clone(),
47 generics: self.generics.clone(),
48 eq_token: self.eq_token.clone(),
49 value: self.value.clone(),
50 }
51 }
52}
53#[cfg(any(feature = "derive", feature = "full"))]
54#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
55impl Clone for crate::AssocType {
56 fn clone(&self) -> Self {
57 crate::AssocType {
58 ident: self.ident.clone(),
59 generics: self.generics.clone(),
60 eq_token: self.eq_token.clone(),
61 ty: self.ty.clone(),
62 }
63 }
64}
65#[cfg(any(feature = "derive", feature = "full"))]
66#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
67impl Copy for crate::AttrStyle {}
68#[cfg(any(feature = "derive", feature = "full"))]
69#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
70impl Clone for crate::AttrStyle {
71 fn clone(&self) -> Self {
72 *self
73 }
74}
75#[cfg(any(feature = "derive", feature = "full"))]
76#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
77impl Clone for crate::Attribute {
78 fn clone(&self) -> Self {
79 crate::Attribute {
80 pound_token: self.pound_token.clone(),
81 style: self.style.clone(),
82 bracket_token: self.bracket_token.clone(),
83 meta: self.meta.clone(),
84 }
85 }
86}
87#[cfg(any(feature = "derive", feature = "full"))]
88#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
89impl Clone for crate::BareFnArg {
90 fn clone(&self) -> Self {
91 crate::BareFnArg {
92 attrs: self.attrs.clone(),
93 name: self.name.clone(),
94 ty: self.ty.clone(),
95 }
96 }
97}
98#[cfg(any(feature = "derive", feature = "full"))]
99#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
100impl Clone for crate::BareVariadic {
101 fn clone(&self) -> Self {
102 crate::BareVariadic {
103 attrs: self.attrs.clone(),
104 name: self.name.clone(),
105 dots: self.dots.clone(),
106 comma: self.comma.clone(),
107 }
108 }
109}
110#[cfg(any(feature = "derive", feature = "full"))]
111#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
112impl Copy for crate::BinOp {}
113#[cfg(any(feature = "derive", feature = "full"))]
114#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
115impl Clone for crate::BinOp {
116 fn clone(&self) -> Self {
117 *self
118 }
119}
120#[cfg(feature = "full")]
121#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
122impl Clone for crate::Block {
123 fn clone(&self) -> Self {
124 crate::Block {
125 brace_token: self.brace_token.clone(),
126 stmts: self.stmts.clone(),
127 }
128 }
129}
130#[cfg(any(feature = "derive", feature = "full"))]
131#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
132impl Clone for crate::BoundLifetimes {
133 fn clone(&self) -> Self {
134 crate::BoundLifetimes {
135 for_token: self.for_token.clone(),
136 lt_token: self.lt_token.clone(),
137 lifetimes: self.lifetimes.clone(),
138 gt_token: self.gt_token.clone(),
139 }
140 }
141}
142#[cfg(feature = "full")]
143#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
144impl Clone for crate::CapturedParam {
145 fn clone(&self) -> Self {
146 match self {
147 crate::CapturedParam::Lifetime(v0: &Lifetime) => {
148 crate::CapturedParam::Lifetime(v0.clone())
149 }
150 crate::CapturedParam::Ident(v0: &Ident) => crate::CapturedParam::Ident(v0.clone()),
151 }
152 }
153}
154#[cfg(any(feature = "derive", feature = "full"))]
155#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
156impl Clone for crate::ConstParam {
157 fn clone(&self) -> Self {
158 crate::ConstParam {
159 attrs: self.attrs.clone(),
160 const_token: self.const_token.clone(),
161 ident: self.ident.clone(),
162 colon_token: self.colon_token.clone(),
163 ty: self.ty.clone(),
164 eq_token: self.eq_token.clone(),
165 default: self.default.clone(),
166 }
167 }
168}
169#[cfg(any(feature = "derive", feature = "full"))]
170#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
171impl Clone for crate::Constraint {
172 fn clone(&self) -> Self {
173 crate::Constraint {
174 ident: self.ident.clone(),
175 generics: self.generics.clone(),
176 colon_token: self.colon_token.clone(),
177 bounds: self.bounds.clone(),
178 }
179 }
180}
181#[cfg(feature = "derive")]
182#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
183impl Clone for crate::Data {
184 fn clone(&self) -> Self {
185 match self {
186 crate::Data::Struct(v0: &DataStruct) => crate::Data::Struct(v0.clone()),
187 crate::Data::Enum(v0: &DataEnum) => crate::Data::Enum(v0.clone()),
188 crate::Data::Union(v0: &DataUnion) => crate::Data::Union(v0.clone()),
189 }
190 }
191}
192#[cfg(feature = "derive")]
193#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
194impl Clone for crate::DataEnum {
195 fn clone(&self) -> Self {
196 crate::DataEnum {
197 enum_token: self.enum_token.clone(),
198 brace_token: self.brace_token.clone(),
199 variants: self.variants.clone(),
200 }
201 }
202}
203#[cfg(feature = "derive")]
204#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
205impl Clone for crate::DataStruct {
206 fn clone(&self) -> Self {
207 crate::DataStruct {
208 struct_token: self.struct_token.clone(),
209 fields: self.fields.clone(),
210 semi_token: self.semi_token.clone(),
211 }
212 }
213}
214#[cfg(feature = "derive")]
215#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
216impl Clone for crate::DataUnion {
217 fn clone(&self) -> Self {
218 crate::DataUnion {
219 union_token: self.union_token.clone(),
220 fields: self.fields.clone(),
221 }
222 }
223}
224#[cfg(feature = "derive")]
225#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
226impl Clone for crate::DeriveInput {
227 fn clone(&self) -> Self {
228 crate::DeriveInput {
229 attrs: self.attrs.clone(),
230 vis: self.vis.clone(),
231 ident: self.ident.clone(),
232 generics: self.generics.clone(),
233 data: self.data.clone(),
234 }
235 }
236}
237#[cfg(any(feature = "derive", feature = "full"))]
238#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
239impl Clone for crate::Expr {
240 fn clone(&self) -> Self {
241 match self {
242 #[cfg(feature = "full")]
243 crate::Expr::Array(v0) => crate::Expr::Array(v0.clone()),
244 #[cfg(feature = "full")]
245 crate::Expr::Assign(v0) => crate::Expr::Assign(v0.clone()),
246 #[cfg(feature = "full")]
247 crate::Expr::Async(v0) => crate::Expr::Async(v0.clone()),
248 #[cfg(feature = "full")]
249 crate::Expr::Await(v0) => crate::Expr::Await(v0.clone()),
250 crate::Expr::Binary(v0) => crate::Expr::Binary(v0.clone()),
251 #[cfg(feature = "full")]
252 crate::Expr::Block(v0) => crate::Expr::Block(v0.clone()),
253 #[cfg(feature = "full")]
254 crate::Expr::Break(v0) => crate::Expr::Break(v0.clone()),
255 crate::Expr::Call(v0) => crate::Expr::Call(v0.clone()),
256 crate::Expr::Cast(v0) => crate::Expr::Cast(v0.clone()),
257 #[cfg(feature = "full")]
258 crate::Expr::Closure(v0) => crate::Expr::Closure(v0.clone()),
259 #[cfg(feature = "full")]
260 crate::Expr::Const(v0) => crate::Expr::Const(v0.clone()),
261 #[cfg(feature = "full")]
262 crate::Expr::Continue(v0) => crate::Expr::Continue(v0.clone()),
263 crate::Expr::Field(v0) => crate::Expr::Field(v0.clone()),
264 #[cfg(feature = "full")]
265 crate::Expr::ForLoop(v0) => crate::Expr::ForLoop(v0.clone()),
266 crate::Expr::Group(v0) => crate::Expr::Group(v0.clone()),
267 #[cfg(feature = "full")]
268 crate::Expr::If(v0) => crate::Expr::If(v0.clone()),
269 crate::Expr::Index(v0) => crate::Expr::Index(v0.clone()),
270 #[cfg(feature = "full")]
271 crate::Expr::Infer(v0) => crate::Expr::Infer(v0.clone()),
272 #[cfg(feature = "full")]
273 crate::Expr::Let(v0) => crate::Expr::Let(v0.clone()),
274 crate::Expr::Lit(v0) => crate::Expr::Lit(v0.clone()),
275 #[cfg(feature = "full")]
276 crate::Expr::Loop(v0) => crate::Expr::Loop(v0.clone()),
277 crate::Expr::Macro(v0) => crate::Expr::Macro(v0.clone()),
278 #[cfg(feature = "full")]
279 crate::Expr::Match(v0) => crate::Expr::Match(v0.clone()),
280 crate::Expr::MethodCall(v0) => crate::Expr::MethodCall(v0.clone()),
281 crate::Expr::Paren(v0) => crate::Expr::Paren(v0.clone()),
282 crate::Expr::Path(v0) => crate::Expr::Path(v0.clone()),
283 #[cfg(feature = "full")]
284 crate::Expr::Range(v0) => crate::Expr::Range(v0.clone()),
285 #[cfg(feature = "full")]
286 crate::Expr::RawAddr(v0) => crate::Expr::RawAddr(v0.clone()),
287 crate::Expr::Reference(v0) => crate::Expr::Reference(v0.clone()),
288 #[cfg(feature = "full")]
289 crate::Expr::Repeat(v0) => crate::Expr::Repeat(v0.clone()),
290 #[cfg(feature = "full")]
291 crate::Expr::Return(v0) => crate::Expr::Return(v0.clone()),
292 crate::Expr::Struct(v0) => crate::Expr::Struct(v0.clone()),
293 #[cfg(feature = "full")]
294 crate::Expr::Try(v0) => crate::Expr::Try(v0.clone()),
295 #[cfg(feature = "full")]
296 crate::Expr::TryBlock(v0) => crate::Expr::TryBlock(v0.clone()),
297 crate::Expr::Tuple(v0) => crate::Expr::Tuple(v0.clone()),
298 crate::Expr::Unary(v0) => crate::Expr::Unary(v0.clone()),
299 #[cfg(feature = "full")]
300 crate::Expr::Unsafe(v0) => crate::Expr::Unsafe(v0.clone()),
301 crate::Expr::Verbatim(v0) => crate::Expr::Verbatim(v0.clone()),
302 #[cfg(feature = "full")]
303 crate::Expr::While(v0) => crate::Expr::While(v0.clone()),
304 #[cfg(feature = "full")]
305 crate::Expr::Yield(v0) => crate::Expr::Yield(v0.clone()),
306 #[cfg(not(feature = "full"))]
307 _ => unreachable!(),
308 }
309 }
310}
311#[cfg(feature = "full")]
312#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
313impl Clone for crate::ExprArray {
314 fn clone(&self) -> Self {
315 crate::ExprArray {
316 attrs: self.attrs.clone(),
317 bracket_token: self.bracket_token.clone(),
318 elems: self.elems.clone(),
319 }
320 }
321}
322#[cfg(feature = "full")]
323#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
324impl Clone for crate::ExprAssign {
325 fn clone(&self) -> Self {
326 crate::ExprAssign {
327 attrs: self.attrs.clone(),
328 left: self.left.clone(),
329 eq_token: self.eq_token.clone(),
330 right: self.right.clone(),
331 }
332 }
333}
334#[cfg(feature = "full")]
335#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
336impl Clone for crate::ExprAsync {
337 fn clone(&self) -> Self {
338 crate::ExprAsync {
339 attrs: self.attrs.clone(),
340 async_token: self.async_token.clone(),
341 capture: self.capture.clone(),
342 block: self.block.clone(),
343 }
344 }
345}
346#[cfg(feature = "full")]
347#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
348impl Clone for crate::ExprAwait {
349 fn clone(&self) -> Self {
350 crate::ExprAwait {
351 attrs: self.attrs.clone(),
352 base: self.base.clone(),
353 dot_token: self.dot_token.clone(),
354 await_token: self.await_token.clone(),
355 }
356 }
357}
358#[cfg(any(feature = "derive", feature = "full"))]
359#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
360impl Clone for crate::ExprBinary {
361 fn clone(&self) -> Self {
362 crate::ExprBinary {
363 attrs: self.attrs.clone(),
364 left: self.left.clone(),
365 op: self.op.clone(),
366 right: self.right.clone(),
367 }
368 }
369}
370#[cfg(feature = "full")]
371#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
372impl Clone for crate::ExprBlock {
373 fn clone(&self) -> Self {
374 crate::ExprBlock {
375 attrs: self.attrs.clone(),
376 label: self.label.clone(),
377 block: self.block.clone(),
378 }
379 }
380}
381#[cfg(feature = "full")]
382#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
383impl Clone for crate::ExprBreak {
384 fn clone(&self) -> Self {
385 crate::ExprBreak {
386 attrs: self.attrs.clone(),
387 break_token: self.break_token.clone(),
388 label: self.label.clone(),
389 expr: self.expr.clone(),
390 }
391 }
392}
393#[cfg(any(feature = "derive", feature = "full"))]
394#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
395impl Clone for crate::ExprCall {
396 fn clone(&self) -> Self {
397 crate::ExprCall {
398 attrs: self.attrs.clone(),
399 func: self.func.clone(),
400 paren_token: self.paren_token.clone(),
401 args: self.args.clone(),
402 }
403 }
404}
405#[cfg(any(feature = "derive", feature = "full"))]
406#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
407impl Clone for crate::ExprCast {
408 fn clone(&self) -> Self {
409 crate::ExprCast {
410 attrs: self.attrs.clone(),
411 expr: self.expr.clone(),
412 as_token: self.as_token.clone(),
413 ty: self.ty.clone(),
414 }
415 }
416}
417#[cfg(feature = "full")]
418#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
419impl Clone for crate::ExprClosure {
420 fn clone(&self) -> Self {
421 crate::ExprClosure {
422 attrs: self.attrs.clone(),
423 lifetimes: self.lifetimes.clone(),
424 constness: self.constness.clone(),
425 movability: self.movability.clone(),
426 asyncness: self.asyncness.clone(),
427 capture: self.capture.clone(),
428 or1_token: self.or1_token.clone(),
429 inputs: self.inputs.clone(),
430 or2_token: self.or2_token.clone(),
431 output: self.output.clone(),
432 body: self.body.clone(),
433 }
434 }
435}
436#[cfg(feature = "full")]
437#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
438impl Clone for crate::ExprConst {
439 fn clone(&self) -> Self {
440 crate::ExprConst {
441 attrs: self.attrs.clone(),
442 const_token: self.const_token.clone(),
443 block: self.block.clone(),
444 }
445 }
446}
447#[cfg(feature = "full")]
448#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
449impl Clone for crate::ExprContinue {
450 fn clone(&self) -> Self {
451 crate::ExprContinue {
452 attrs: self.attrs.clone(),
453 continue_token: self.continue_token.clone(),
454 label: self.label.clone(),
455 }
456 }
457}
458#[cfg(any(feature = "derive", feature = "full"))]
459#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
460impl Clone for crate::ExprField {
461 fn clone(&self) -> Self {
462 crate::ExprField {
463 attrs: self.attrs.clone(),
464 base: self.base.clone(),
465 dot_token: self.dot_token.clone(),
466 member: self.member.clone(),
467 }
468 }
469}
470#[cfg(feature = "full")]
471#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
472impl Clone for crate::ExprForLoop {
473 fn clone(&self) -> Self {
474 crate::ExprForLoop {
475 attrs: self.attrs.clone(),
476 label: self.label.clone(),
477 for_token: self.for_token.clone(),
478 pat: self.pat.clone(),
479 in_token: self.in_token.clone(),
480 expr: self.expr.clone(),
481 body: self.body.clone(),
482 }
483 }
484}
485#[cfg(any(feature = "derive", feature = "full"))]
486#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
487impl Clone for crate::ExprGroup {
488 fn clone(&self) -> Self {
489 crate::ExprGroup {
490 attrs: self.attrs.clone(),
491 group_token: self.group_token.clone(),
492 expr: self.expr.clone(),
493 }
494 }
495}
496#[cfg(feature = "full")]
497#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
498impl Clone for crate::ExprIf {
499 fn clone(&self) -> Self {
500 crate::ExprIf {
501 attrs: self.attrs.clone(),
502 if_token: self.if_token.clone(),
503 cond: self.cond.clone(),
504 then_branch: self.then_branch.clone(),
505 else_branch: self.else_branch.clone(),
506 }
507 }
508}
509#[cfg(any(feature = "derive", feature = "full"))]
510#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
511impl Clone for crate::ExprIndex {
512 fn clone(&self) -> Self {
513 crate::ExprIndex {
514 attrs: self.attrs.clone(),
515 expr: self.expr.clone(),
516 bracket_token: self.bracket_token.clone(),
517 index: self.index.clone(),
518 }
519 }
520}
521#[cfg(feature = "full")]
522#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
523impl Clone for crate::ExprInfer {
524 fn clone(&self) -> Self {
525 crate::ExprInfer {
526 attrs: self.attrs.clone(),
527 underscore_token: self.underscore_token.clone(),
528 }
529 }
530}
531#[cfg(feature = "full")]
532#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
533impl Clone for crate::ExprLet {
534 fn clone(&self) -> Self {
535 crate::ExprLet {
536 attrs: self.attrs.clone(),
537 let_token: self.let_token.clone(),
538 pat: self.pat.clone(),
539 eq_token: self.eq_token.clone(),
540 expr: self.expr.clone(),
541 }
542 }
543}
544#[cfg(any(feature = "derive", feature = "full"))]
545#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
546impl Clone for crate::ExprLit {
547 fn clone(&self) -> Self {
548 crate::ExprLit {
549 attrs: self.attrs.clone(),
550 lit: self.lit.clone(),
551 }
552 }
553}
554#[cfg(feature = "full")]
555#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
556impl Clone for crate::ExprLoop {
557 fn clone(&self) -> Self {
558 crate::ExprLoop {
559 attrs: self.attrs.clone(),
560 label: self.label.clone(),
561 loop_token: self.loop_token.clone(),
562 body: self.body.clone(),
563 }
564 }
565}
566#[cfg(any(feature = "derive", feature = "full"))]
567#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
568impl Clone for crate::ExprMacro {
569 fn clone(&self) -> Self {
570 crate::ExprMacro {
571 attrs: self.attrs.clone(),
572 mac: self.mac.clone(),
573 }
574 }
575}
576#[cfg(feature = "full")]
577#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
578impl Clone for crate::ExprMatch {
579 fn clone(&self) -> Self {
580 crate::ExprMatch {
581 attrs: self.attrs.clone(),
582 match_token: self.match_token.clone(),
583 expr: self.expr.clone(),
584 brace_token: self.brace_token.clone(),
585 arms: self.arms.clone(),
586 }
587 }
588}
589#[cfg(any(feature = "derive", feature = "full"))]
590#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
591impl Clone for crate::ExprMethodCall {
592 fn clone(&self) -> Self {
593 crate::ExprMethodCall {
594 attrs: self.attrs.clone(),
595 receiver: self.receiver.clone(),
596 dot_token: self.dot_token.clone(),
597 method: self.method.clone(),
598 turbofish: self.turbofish.clone(),
599 paren_token: self.paren_token.clone(),
600 args: self.args.clone(),
601 }
602 }
603}
604#[cfg(any(feature = "derive", feature = "full"))]
605#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
606impl Clone for crate::ExprParen {
607 fn clone(&self) -> Self {
608 crate::ExprParen {
609 attrs: self.attrs.clone(),
610 paren_token: self.paren_token.clone(),
611 expr: self.expr.clone(),
612 }
613 }
614}
615#[cfg(any(feature = "derive", feature = "full"))]
616#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
617impl Clone for crate::ExprPath {
618 fn clone(&self) -> Self {
619 crate::ExprPath {
620 attrs: self.attrs.clone(),
621 qself: self.qself.clone(),
622 path: self.path.clone(),
623 }
624 }
625}
626#[cfg(feature = "full")]
627#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
628impl Clone for crate::ExprRange {
629 fn clone(&self) -> Self {
630 crate::ExprRange {
631 attrs: self.attrs.clone(),
632 start: self.start.clone(),
633 limits: self.limits.clone(),
634 end: self.end.clone(),
635 }
636 }
637}
638#[cfg(feature = "full")]
639#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
640impl Clone for crate::ExprRawAddr {
641 fn clone(&self) -> Self {
642 crate::ExprRawAddr {
643 attrs: self.attrs.clone(),
644 and_token: self.and_token.clone(),
645 raw: self.raw.clone(),
646 mutability: self.mutability.clone(),
647 expr: self.expr.clone(),
648 }
649 }
650}
651#[cfg(any(feature = "derive", feature = "full"))]
652#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
653impl Clone for crate::ExprReference {
654 fn clone(&self) -> Self {
655 crate::ExprReference {
656 attrs: self.attrs.clone(),
657 and_token: self.and_token.clone(),
658 mutability: self.mutability.clone(),
659 expr: self.expr.clone(),
660 }
661 }
662}
663#[cfg(feature = "full")]
664#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
665impl Clone for crate::ExprRepeat {
666 fn clone(&self) -> Self {
667 crate::ExprRepeat {
668 attrs: self.attrs.clone(),
669 bracket_token: self.bracket_token.clone(),
670 expr: self.expr.clone(),
671 semi_token: self.semi_token.clone(),
672 len: self.len.clone(),
673 }
674 }
675}
676#[cfg(feature = "full")]
677#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
678impl Clone for crate::ExprReturn {
679 fn clone(&self) -> Self {
680 crate::ExprReturn {
681 attrs: self.attrs.clone(),
682 return_token: self.return_token.clone(),
683 expr: self.expr.clone(),
684 }
685 }
686}
687#[cfg(any(feature = "derive", feature = "full"))]
688#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
689impl Clone for crate::ExprStruct {
690 fn clone(&self) -> Self {
691 crate::ExprStruct {
692 attrs: self.attrs.clone(),
693 qself: self.qself.clone(),
694 path: self.path.clone(),
695 brace_token: self.brace_token.clone(),
696 fields: self.fields.clone(),
697 dot2_token: self.dot2_token.clone(),
698 rest: self.rest.clone(),
699 }
700 }
701}
702#[cfg(feature = "full")]
703#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
704impl Clone for crate::ExprTry {
705 fn clone(&self) -> Self {
706 crate::ExprTry {
707 attrs: self.attrs.clone(),
708 expr: self.expr.clone(),
709 question_token: self.question_token.clone(),
710 }
711 }
712}
713#[cfg(feature = "full")]
714#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
715impl Clone for crate::ExprTryBlock {
716 fn clone(&self) -> Self {
717 crate::ExprTryBlock {
718 attrs: self.attrs.clone(),
719 try_token: self.try_token.clone(),
720 block: self.block.clone(),
721 }
722 }
723}
724#[cfg(any(feature = "derive", feature = "full"))]
725#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
726impl Clone for crate::ExprTuple {
727 fn clone(&self) -> Self {
728 crate::ExprTuple {
729 attrs: self.attrs.clone(),
730 paren_token: self.paren_token.clone(),
731 elems: self.elems.clone(),
732 }
733 }
734}
735#[cfg(any(feature = "derive", feature = "full"))]
736#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
737impl Clone for crate::ExprUnary {
738 fn clone(&self) -> Self {
739 crate::ExprUnary {
740 attrs: self.attrs.clone(),
741 op: self.op.clone(),
742 expr: self.expr.clone(),
743 }
744 }
745}
746#[cfg(feature = "full")]
747#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
748impl Clone for crate::ExprUnsafe {
749 fn clone(&self) -> Self {
750 crate::ExprUnsafe {
751 attrs: self.attrs.clone(),
752 unsafe_token: self.unsafe_token.clone(),
753 block: self.block.clone(),
754 }
755 }
756}
757#[cfg(feature = "full")]
758#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
759impl Clone for crate::ExprWhile {
760 fn clone(&self) -> Self {
761 crate::ExprWhile {
762 attrs: self.attrs.clone(),
763 label: self.label.clone(),
764 while_token: self.while_token.clone(),
765 cond: self.cond.clone(),
766 body: self.body.clone(),
767 }
768 }
769}
770#[cfg(feature = "full")]
771#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
772impl Clone for crate::ExprYield {
773 fn clone(&self) -> Self {
774 crate::ExprYield {
775 attrs: self.attrs.clone(),
776 yield_token: self.yield_token.clone(),
777 expr: self.expr.clone(),
778 }
779 }
780}
781#[cfg(any(feature = "derive", feature = "full"))]
782#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
783impl Clone for crate::Field {
784 fn clone(&self) -> Self {
785 crate::Field {
786 attrs: self.attrs.clone(),
787 vis: self.vis.clone(),
788 mutability: self.mutability.clone(),
789 ident: self.ident.clone(),
790 colon_token: self.colon_token.clone(),
791 ty: self.ty.clone(),
792 }
793 }
794}
795#[cfg(any(feature = "derive", feature = "full"))]
796#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
797impl Clone for crate::FieldMutability {
798 fn clone(&self) -> Self {
799 match self {
800 crate::FieldMutability::None => crate::FieldMutability::None,
801 }
802 }
803}
804#[cfg(feature = "full")]
805#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
806impl Clone for crate::FieldPat {
807 fn clone(&self) -> Self {
808 crate::FieldPat {
809 attrs: self.attrs.clone(),
810 member: self.member.clone(),
811 colon_token: self.colon_token.clone(),
812 pat: self.pat.clone(),
813 }
814 }
815}
816#[cfg(any(feature = "derive", feature = "full"))]
817#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
818impl Clone for crate::FieldValue {
819 fn clone(&self) -> Self {
820 crate::FieldValue {
821 attrs: self.attrs.clone(),
822 member: self.member.clone(),
823 colon_token: self.colon_token.clone(),
824 expr: self.expr.clone(),
825 }
826 }
827}
828#[cfg(any(feature = "derive", feature = "full"))]
829#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
830impl Clone for crate::Fields {
831 fn clone(&self) -> Self {
832 match self {
833 crate::Fields::Named(v0: &FieldsNamed) => crate::Fields::Named(v0.clone()),
834 crate::Fields::Unnamed(v0: &FieldsUnnamed) => crate::Fields::Unnamed(v0.clone()),
835 crate::Fields::Unit => crate::Fields::Unit,
836 }
837 }
838}
839#[cfg(any(feature = "derive", feature = "full"))]
840#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
841impl Clone for crate::FieldsNamed {
842 fn clone(&self) -> Self {
843 crate::FieldsNamed {
844 brace_token: self.brace_token.clone(),
845 named: self.named.clone(),
846 }
847 }
848}
849#[cfg(any(feature = "derive", feature = "full"))]
850#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
851impl Clone for crate::FieldsUnnamed {
852 fn clone(&self) -> Self {
853 crate::FieldsUnnamed {
854 paren_token: self.paren_token.clone(),
855 unnamed: self.unnamed.clone(),
856 }
857 }
858}
859#[cfg(feature = "full")]
860#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
861impl Clone for crate::File {
862 fn clone(&self) -> Self {
863 crate::File {
864 shebang: self.shebang.clone(),
865 attrs: self.attrs.clone(),
866 items: self.items.clone(),
867 }
868 }
869}
870#[cfg(feature = "full")]
871#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
872impl Clone for crate::FnArg {
873 fn clone(&self) -> Self {
874 match self {
875 crate::FnArg::Receiver(v0: &Receiver) => crate::FnArg::Receiver(v0.clone()),
876 crate::FnArg::Typed(v0: &PatType) => crate::FnArg::Typed(v0.clone()),
877 }
878 }
879}
880#[cfg(feature = "full")]
881#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
882impl Clone for crate::ForeignItem {
883 fn clone(&self) -> Self {
884 match self {
885 crate::ForeignItem::Fn(v0: &ForeignItemFn) => crate::ForeignItem::Fn(v0.clone()),
886 crate::ForeignItem::Static(v0: &ForeignItemStatic) => crate::ForeignItem::Static(v0.clone()),
887 crate::ForeignItem::Type(v0: &ForeignItemType) => crate::ForeignItem::Type(v0.clone()),
888 crate::ForeignItem::Macro(v0: &ForeignItemMacro) => crate::ForeignItem::Macro(v0.clone()),
889 crate::ForeignItem::Verbatim(v0: &TokenStream) => crate::ForeignItem::Verbatim(v0.clone()),
890 }
891 }
892}
893#[cfg(feature = "full")]
894#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
895impl Clone for crate::ForeignItemFn {
896 fn clone(&self) -> Self {
897 crate::ForeignItemFn {
898 attrs: self.attrs.clone(),
899 vis: self.vis.clone(),
900 sig: self.sig.clone(),
901 semi_token: self.semi_token.clone(),
902 }
903 }
904}
905#[cfg(feature = "full")]
906#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
907impl Clone for crate::ForeignItemMacro {
908 fn clone(&self) -> Self {
909 crate::ForeignItemMacro {
910 attrs: self.attrs.clone(),
911 mac: self.mac.clone(),
912 semi_token: self.semi_token.clone(),
913 }
914 }
915}
916#[cfg(feature = "full")]
917#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
918impl Clone for crate::ForeignItemStatic {
919 fn clone(&self) -> Self {
920 crate::ForeignItemStatic {
921 attrs: self.attrs.clone(),
922 vis: self.vis.clone(),
923 static_token: self.static_token.clone(),
924 mutability: self.mutability.clone(),
925 ident: self.ident.clone(),
926 colon_token: self.colon_token.clone(),
927 ty: self.ty.clone(),
928 semi_token: self.semi_token.clone(),
929 }
930 }
931}
932#[cfg(feature = "full")]
933#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
934impl Clone for crate::ForeignItemType {
935 fn clone(&self) -> Self {
936 crate::ForeignItemType {
937 attrs: self.attrs.clone(),
938 vis: self.vis.clone(),
939 type_token: self.type_token.clone(),
940 ident: self.ident.clone(),
941 generics: self.generics.clone(),
942 semi_token: self.semi_token.clone(),
943 }
944 }
945}
946#[cfg(any(feature = "derive", feature = "full"))]
947#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
948impl Clone for crate::GenericArgument {
949 fn clone(&self) -> Self {
950 match self {
951 crate::GenericArgument::Lifetime(v0: &Lifetime) => {
952 crate::GenericArgument::Lifetime(v0.clone())
953 }
954 crate::GenericArgument::Type(v0: &Type) => crate::GenericArgument::Type(v0.clone()),
955 crate::GenericArgument::Const(v0: &Expr) => {
956 crate::GenericArgument::Const(v0.clone())
957 }
958 crate::GenericArgument::AssocType(v0: &AssocType) => {
959 crate::GenericArgument::AssocType(v0.clone())
960 }
961 crate::GenericArgument::AssocConst(v0: &AssocConst) => {
962 crate::GenericArgument::AssocConst(v0.clone())
963 }
964 crate::GenericArgument::Constraint(v0: &Constraint) => {
965 crate::GenericArgument::Constraint(v0.clone())
966 }
967 }
968 }
969}
970#[cfg(any(feature = "derive", feature = "full"))]
971#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
972impl Clone for crate::GenericParam {
973 fn clone(&self) -> Self {
974 match self {
975 crate::GenericParam::Lifetime(v0: &LifetimeParam) => {
976 crate::GenericParam::Lifetime(v0.clone())
977 }
978 crate::GenericParam::Type(v0: &TypeParam) => crate::GenericParam::Type(v0.clone()),
979 crate::GenericParam::Const(v0: &ConstParam) => crate::GenericParam::Const(v0.clone()),
980 }
981 }
982}
983#[cfg(any(feature = "derive", feature = "full"))]
984#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
985impl Clone for crate::Generics {
986 fn clone(&self) -> Self {
987 crate::Generics {
988 lt_token: self.lt_token.clone(),
989 params: self.params.clone(),
990 gt_token: self.gt_token.clone(),
991 where_clause: self.where_clause.clone(),
992 }
993 }
994}
995#[cfg(feature = "full")]
996#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
997impl Clone for crate::ImplItem {
998 fn clone(&self) -> Self {
999 match self {
1000 crate::ImplItem::Const(v0: &ImplItemConst) => crate::ImplItem::Const(v0.clone()),
1001 crate::ImplItem::Fn(v0: &ImplItemFn) => crate::ImplItem::Fn(v0.clone()),
1002 crate::ImplItem::Type(v0: &ImplItemType) => crate::ImplItem::Type(v0.clone()),
1003 crate::ImplItem::Macro(v0: &ImplItemMacro) => crate::ImplItem::Macro(v0.clone()),
1004 crate::ImplItem::Verbatim(v0: &TokenStream) => crate::ImplItem::Verbatim(v0.clone()),
1005 }
1006 }
1007}
1008#[cfg(feature = "full")]
1009#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1010impl Clone for crate::ImplItemConst {
1011 fn clone(&self) -> Self {
1012 crate::ImplItemConst {
1013 attrs: self.attrs.clone(),
1014 vis: self.vis.clone(),
1015 defaultness: self.defaultness.clone(),
1016 const_token: self.const_token.clone(),
1017 ident: self.ident.clone(),
1018 generics: self.generics.clone(),
1019 colon_token: self.colon_token.clone(),
1020 ty: self.ty.clone(),
1021 eq_token: self.eq_token.clone(),
1022 expr: self.expr.clone(),
1023 semi_token: self.semi_token.clone(),
1024 }
1025 }
1026}
1027#[cfg(feature = "full")]
1028#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1029impl Clone for crate::ImplItemFn {
1030 fn clone(&self) -> Self {
1031 crate::ImplItemFn {
1032 attrs: self.attrs.clone(),
1033 vis: self.vis.clone(),
1034 defaultness: self.defaultness.clone(),
1035 sig: self.sig.clone(),
1036 block: self.block.clone(),
1037 }
1038 }
1039}
1040#[cfg(feature = "full")]
1041#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1042impl Clone for crate::ImplItemMacro {
1043 fn clone(&self) -> Self {
1044 crate::ImplItemMacro {
1045 attrs: self.attrs.clone(),
1046 mac: self.mac.clone(),
1047 semi_token: self.semi_token.clone(),
1048 }
1049 }
1050}
1051#[cfg(feature = "full")]
1052#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1053impl Clone for crate::ImplItemType {
1054 fn clone(&self) -> Self {
1055 crate::ImplItemType {
1056 attrs: self.attrs.clone(),
1057 vis: self.vis.clone(),
1058 defaultness: self.defaultness.clone(),
1059 type_token: self.type_token.clone(),
1060 ident: self.ident.clone(),
1061 generics: self.generics.clone(),
1062 eq_token: self.eq_token.clone(),
1063 ty: self.ty.clone(),
1064 semi_token: self.semi_token.clone(),
1065 }
1066 }
1067}
1068#[cfg(feature = "full")]
1069#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1070impl Clone for crate::ImplRestriction {
1071 fn clone(&self) -> Self {
1072 match *self {}
1073 }
1074}
1075#[cfg(any(feature = "derive", feature = "full"))]
1076#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1077impl Clone for crate::Index {
1078 fn clone(&self) -> Self {
1079 crate::Index {
1080 index: self.index.clone(),
1081 span: self.span.clone(),
1082 }
1083 }
1084}
1085#[cfg(feature = "full")]
1086#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1087impl Clone for crate::Item {
1088 fn clone(&self) -> Self {
1089 match self {
1090 crate::Item::Const(v0: &ItemConst) => crate::Item::Const(v0.clone()),
1091 crate::Item::Enum(v0: &ItemEnum) => crate::Item::Enum(v0.clone()),
1092 crate::Item::ExternCrate(v0: &ItemExternCrate) => crate::Item::ExternCrate(v0.clone()),
1093 crate::Item::Fn(v0: &ItemFn) => crate::Item::Fn(v0.clone()),
1094 crate::Item::ForeignMod(v0: &ItemForeignMod) => crate::Item::ForeignMod(v0.clone()),
1095 crate::Item::Impl(v0: &ItemImpl) => crate::Item::Impl(v0.clone()),
1096 crate::Item::Macro(v0: &ItemMacro) => crate::Item::Macro(v0.clone()),
1097 crate::Item::Mod(v0: &ItemMod) => crate::Item::Mod(v0.clone()),
1098 crate::Item::Static(v0: &ItemStatic) => crate::Item::Static(v0.clone()),
1099 crate::Item::Struct(v0: &ItemStruct) => crate::Item::Struct(v0.clone()),
1100 crate::Item::Trait(v0: &ItemTrait) => crate::Item::Trait(v0.clone()),
1101 crate::Item::TraitAlias(v0: &ItemTraitAlias) => crate::Item::TraitAlias(v0.clone()),
1102 crate::Item::Type(v0: &ItemType) => crate::Item::Type(v0.clone()),
1103 crate::Item::Union(v0: &ItemUnion) => crate::Item::Union(v0.clone()),
1104 crate::Item::Use(v0: &ItemUse) => crate::Item::Use(v0.clone()),
1105 crate::Item::Verbatim(v0: &TokenStream) => crate::Item::Verbatim(v0.clone()),
1106 }
1107 }
1108}
1109#[cfg(feature = "full")]
1110#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1111impl Clone for crate::ItemConst {
1112 fn clone(&self) -> Self {
1113 crate::ItemConst {
1114 attrs: self.attrs.clone(),
1115 vis: self.vis.clone(),
1116 const_token: self.const_token.clone(),
1117 ident: self.ident.clone(),
1118 generics: self.generics.clone(),
1119 colon_token: self.colon_token.clone(),
1120 ty: self.ty.clone(),
1121 eq_token: self.eq_token.clone(),
1122 expr: self.expr.clone(),
1123 semi_token: self.semi_token.clone(),
1124 }
1125 }
1126}
1127#[cfg(feature = "full")]
1128#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1129impl Clone for crate::ItemEnum {
1130 fn clone(&self) -> Self {
1131 crate::ItemEnum {
1132 attrs: self.attrs.clone(),
1133 vis: self.vis.clone(),
1134 enum_token: self.enum_token.clone(),
1135 ident: self.ident.clone(),
1136 generics: self.generics.clone(),
1137 brace_token: self.brace_token.clone(),
1138 variants: self.variants.clone(),
1139 }
1140 }
1141}
1142#[cfg(feature = "full")]
1143#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1144impl Clone for crate::ItemExternCrate {
1145 fn clone(&self) -> Self {
1146 crate::ItemExternCrate {
1147 attrs: self.attrs.clone(),
1148 vis: self.vis.clone(),
1149 extern_token: self.extern_token.clone(),
1150 crate_token: self.crate_token.clone(),
1151 ident: self.ident.clone(),
1152 rename: self.rename.clone(),
1153 semi_token: self.semi_token.clone(),
1154 }
1155 }
1156}
1157#[cfg(feature = "full")]
1158#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1159impl Clone for crate::ItemFn {
1160 fn clone(&self) -> Self {
1161 crate::ItemFn {
1162 attrs: self.attrs.clone(),
1163 vis: self.vis.clone(),
1164 sig: self.sig.clone(),
1165 block: self.block.clone(),
1166 }
1167 }
1168}
1169#[cfg(feature = "full")]
1170#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1171impl Clone for crate::ItemForeignMod {
1172 fn clone(&self) -> Self {
1173 crate::ItemForeignMod {
1174 attrs: self.attrs.clone(),
1175 unsafety: self.unsafety.clone(),
1176 abi: self.abi.clone(),
1177 brace_token: self.brace_token.clone(),
1178 items: self.items.clone(),
1179 }
1180 }
1181}
1182#[cfg(feature = "full")]
1183#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1184impl Clone for crate::ItemImpl {
1185 fn clone(&self) -> Self {
1186 crate::ItemImpl {
1187 attrs: self.attrs.clone(),
1188 defaultness: self.defaultness.clone(),
1189 unsafety: self.unsafety.clone(),
1190 impl_token: self.impl_token.clone(),
1191 generics: self.generics.clone(),
1192 trait_: self.trait_.clone(),
1193 self_ty: self.self_ty.clone(),
1194 brace_token: self.brace_token.clone(),
1195 items: self.items.clone(),
1196 }
1197 }
1198}
1199#[cfg(feature = "full")]
1200#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1201impl Clone for crate::ItemMacro {
1202 fn clone(&self) -> Self {
1203 crate::ItemMacro {
1204 attrs: self.attrs.clone(),
1205 ident: self.ident.clone(),
1206 mac: self.mac.clone(),
1207 semi_token: self.semi_token.clone(),
1208 }
1209 }
1210}
1211#[cfg(feature = "full")]
1212#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1213impl Clone for crate::ItemMod {
1214 fn clone(&self) -> Self {
1215 crate::ItemMod {
1216 attrs: self.attrs.clone(),
1217 vis: self.vis.clone(),
1218 unsafety: self.unsafety.clone(),
1219 mod_token: self.mod_token.clone(),
1220 ident: self.ident.clone(),
1221 content: self.content.clone(),
1222 semi: self.semi.clone(),
1223 }
1224 }
1225}
1226#[cfg(feature = "full")]
1227#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1228impl Clone for crate::ItemStatic {
1229 fn clone(&self) -> Self {
1230 crate::ItemStatic {
1231 attrs: self.attrs.clone(),
1232 vis: self.vis.clone(),
1233 static_token: self.static_token.clone(),
1234 mutability: self.mutability.clone(),
1235 ident: self.ident.clone(),
1236 colon_token: self.colon_token.clone(),
1237 ty: self.ty.clone(),
1238 eq_token: self.eq_token.clone(),
1239 expr: self.expr.clone(),
1240 semi_token: self.semi_token.clone(),
1241 }
1242 }
1243}
1244#[cfg(feature = "full")]
1245#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1246impl Clone for crate::ItemStruct {
1247 fn clone(&self) -> Self {
1248 crate::ItemStruct {
1249 attrs: self.attrs.clone(),
1250 vis: self.vis.clone(),
1251 struct_token: self.struct_token.clone(),
1252 ident: self.ident.clone(),
1253 generics: self.generics.clone(),
1254 fields: self.fields.clone(),
1255 semi_token: self.semi_token.clone(),
1256 }
1257 }
1258}
1259#[cfg(feature = "full")]
1260#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1261impl Clone for crate::ItemTrait {
1262 fn clone(&self) -> Self {
1263 crate::ItemTrait {
1264 attrs: self.attrs.clone(),
1265 vis: self.vis.clone(),
1266 unsafety: self.unsafety.clone(),
1267 auto_token: self.auto_token.clone(),
1268 restriction: self.restriction.clone(),
1269 trait_token: self.trait_token.clone(),
1270 ident: self.ident.clone(),
1271 generics: self.generics.clone(),
1272 colon_token: self.colon_token.clone(),
1273 supertraits: self.supertraits.clone(),
1274 brace_token: self.brace_token.clone(),
1275 items: self.items.clone(),
1276 }
1277 }
1278}
1279#[cfg(feature = "full")]
1280#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1281impl Clone for crate::ItemTraitAlias {
1282 fn clone(&self) -> Self {
1283 crate::ItemTraitAlias {
1284 attrs: self.attrs.clone(),
1285 vis: self.vis.clone(),
1286 trait_token: self.trait_token.clone(),
1287 ident: self.ident.clone(),
1288 generics: self.generics.clone(),
1289 eq_token: self.eq_token.clone(),
1290 bounds: self.bounds.clone(),
1291 semi_token: self.semi_token.clone(),
1292 }
1293 }
1294}
1295#[cfg(feature = "full")]
1296#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1297impl Clone for crate::ItemType {
1298 fn clone(&self) -> Self {
1299 crate::ItemType {
1300 attrs: self.attrs.clone(),
1301 vis: self.vis.clone(),
1302 type_token: self.type_token.clone(),
1303 ident: self.ident.clone(),
1304 generics: self.generics.clone(),
1305 eq_token: self.eq_token.clone(),
1306 ty: self.ty.clone(),
1307 semi_token: self.semi_token.clone(),
1308 }
1309 }
1310}
1311#[cfg(feature = "full")]
1312#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1313impl Clone for crate::ItemUnion {
1314 fn clone(&self) -> Self {
1315 crate::ItemUnion {
1316 attrs: self.attrs.clone(),
1317 vis: self.vis.clone(),
1318 union_token: self.union_token.clone(),
1319 ident: self.ident.clone(),
1320 generics: self.generics.clone(),
1321 fields: self.fields.clone(),
1322 }
1323 }
1324}
1325#[cfg(feature = "full")]
1326#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1327impl Clone for crate::ItemUse {
1328 fn clone(&self) -> Self {
1329 crate::ItemUse {
1330 attrs: self.attrs.clone(),
1331 vis: self.vis.clone(),
1332 use_token: self.use_token.clone(),
1333 leading_colon: self.leading_colon.clone(),
1334 tree: self.tree.clone(),
1335 semi_token: self.semi_token.clone(),
1336 }
1337 }
1338}
1339#[cfg(feature = "full")]
1340#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1341impl Clone for crate::Label {
1342 fn clone(&self) -> Self {
1343 crate::Label {
1344 name: self.name.clone(),
1345 colon_token: self.colon_token.clone(),
1346 }
1347 }
1348}
1349#[cfg(any(feature = "derive", feature = "full"))]
1350#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1351impl Clone for crate::LifetimeParam {
1352 fn clone(&self) -> Self {
1353 crate::LifetimeParam {
1354 attrs: self.attrs.clone(),
1355 lifetime: self.lifetime.clone(),
1356 colon_token: self.colon_token.clone(),
1357 bounds: self.bounds.clone(),
1358 }
1359 }
1360}
1361#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1362impl Clone for crate::Lit {
1363 fn clone(&self) -> Self {
1364 match self {
1365 crate::Lit::Str(v0: &LitStr) => crate::Lit::Str(v0.clone()),
1366 crate::Lit::ByteStr(v0: &LitByteStr) => crate::Lit::ByteStr(v0.clone()),
1367 crate::Lit::CStr(v0: &LitCStr) => crate::Lit::CStr(v0.clone()),
1368 crate::Lit::Byte(v0: &LitByte) => crate::Lit::Byte(v0.clone()),
1369 crate::Lit::Char(v0: &LitChar) => crate::Lit::Char(v0.clone()),
1370 crate::Lit::Int(v0: &LitInt) => crate::Lit::Int(v0.clone()),
1371 crate::Lit::Float(v0: &LitFloat) => crate::Lit::Float(v0.clone()),
1372 crate::Lit::Bool(v0: &LitBool) => crate::Lit::Bool(v0.clone()),
1373 crate::Lit::Verbatim(v0: &Literal) => crate::Lit::Verbatim(v0.clone()),
1374 }
1375 }
1376}
1377#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1378impl Clone for crate::LitBool {
1379 fn clone(&self) -> Self {
1380 crate::LitBool {
1381 value: self.value.clone(),
1382 span: self.span.clone(),
1383 }
1384 }
1385}
1386#[cfg(feature = "full")]
1387#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1388impl Clone for crate::Local {
1389 fn clone(&self) -> Self {
1390 crate::Local {
1391 attrs: self.attrs.clone(),
1392 let_token: self.let_token.clone(),
1393 pat: self.pat.clone(),
1394 init: self.init.clone(),
1395 semi_token: self.semi_token.clone(),
1396 }
1397 }
1398}
1399#[cfg(feature = "full")]
1400#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1401impl Clone for crate::LocalInit {
1402 fn clone(&self) -> Self {
1403 crate::LocalInit {
1404 eq_token: self.eq_token.clone(),
1405 expr: self.expr.clone(),
1406 diverge: self.diverge.clone(),
1407 }
1408 }
1409}
1410#[cfg(any(feature = "derive", feature = "full"))]
1411#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1412impl Clone for crate::Macro {
1413 fn clone(&self) -> Self {
1414 crate::Macro {
1415 path: self.path.clone(),
1416 bang_token: self.bang_token.clone(),
1417 delimiter: self.delimiter.clone(),
1418 tokens: self.tokens.clone(),
1419 }
1420 }
1421}
1422#[cfg(any(feature = "derive", feature = "full"))]
1423#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1424impl Clone for crate::MacroDelimiter {
1425 fn clone(&self) -> Self {
1426 match self {
1427 crate::MacroDelimiter::Paren(v0: &Paren) => crate::MacroDelimiter::Paren(v0.clone()),
1428 crate::MacroDelimiter::Brace(v0: &Brace) => crate::MacroDelimiter::Brace(v0.clone()),
1429 crate::MacroDelimiter::Bracket(v0: &Bracket) => {
1430 crate::MacroDelimiter::Bracket(v0.clone())
1431 }
1432 }
1433 }
1434}
1435#[cfg(any(feature = "derive", feature = "full"))]
1436#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1437impl Clone for crate::Member {
1438 fn clone(&self) -> Self {
1439 match self {
1440 crate::Member::Named(v0: &Ident) => crate::Member::Named(v0.clone()),
1441 crate::Member::Unnamed(v0: &Index) => crate::Member::Unnamed(v0.clone()),
1442 }
1443 }
1444}
1445#[cfg(any(feature = "derive", feature = "full"))]
1446#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1447impl Clone for crate::Meta {
1448 fn clone(&self) -> Self {
1449 match self {
1450 crate::Meta::Path(v0: &Path) => crate::Meta::Path(v0.clone()),
1451 crate::Meta::List(v0: &MetaList) => crate::Meta::List(v0.clone()),
1452 crate::Meta::NameValue(v0: &MetaNameValue) => crate::Meta::NameValue(v0.clone()),
1453 }
1454 }
1455}
1456#[cfg(any(feature = "derive", feature = "full"))]
1457#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1458impl Clone for crate::MetaList {
1459 fn clone(&self) -> Self {
1460 crate::MetaList {
1461 path: self.path.clone(),
1462 delimiter: self.delimiter.clone(),
1463 tokens: self.tokens.clone(),
1464 }
1465 }
1466}
1467#[cfg(any(feature = "derive", feature = "full"))]
1468#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1469impl Clone for crate::MetaNameValue {
1470 fn clone(&self) -> Self {
1471 crate::MetaNameValue {
1472 path: self.path.clone(),
1473 eq_token: self.eq_token.clone(),
1474 value: self.value.clone(),
1475 }
1476 }
1477}
1478#[cfg(any(feature = "derive", feature = "full"))]
1479#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1480impl Clone for crate::ParenthesizedGenericArguments {
1481 fn clone(&self) -> Self {
1482 crate::ParenthesizedGenericArguments {
1483 paren_token: self.paren_token.clone(),
1484 inputs: self.inputs.clone(),
1485 output: self.output.clone(),
1486 }
1487 }
1488}
1489#[cfg(feature = "full")]
1490#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1491impl Clone for crate::Pat {
1492 fn clone(&self) -> Self {
1493 match self {
1494 crate::Pat::Const(v0: &ExprConst) => crate::Pat::Const(v0.clone()),
1495 crate::Pat::Ident(v0: &PatIdent) => crate::Pat::Ident(v0.clone()),
1496 crate::Pat::Lit(v0: &ExprLit) => crate::Pat::Lit(v0.clone()),
1497 crate::Pat::Macro(v0: &ExprMacro) => crate::Pat::Macro(v0.clone()),
1498 crate::Pat::Or(v0: &PatOr) => crate::Pat::Or(v0.clone()),
1499 crate::Pat::Paren(v0: &PatParen) => crate::Pat::Paren(v0.clone()),
1500 crate::Pat::Path(v0: &ExprPath) => crate::Pat::Path(v0.clone()),
1501 crate::Pat::Range(v0: &ExprRange) => crate::Pat::Range(v0.clone()),
1502 crate::Pat::Reference(v0: &PatReference) => crate::Pat::Reference(v0.clone()),
1503 crate::Pat::Rest(v0: &PatRest) => crate::Pat::Rest(v0.clone()),
1504 crate::Pat::Slice(v0: &PatSlice) => crate::Pat::Slice(v0.clone()),
1505 crate::Pat::Struct(v0: &PatStruct) => crate::Pat::Struct(v0.clone()),
1506 crate::Pat::Tuple(v0: &PatTuple) => crate::Pat::Tuple(v0.clone()),
1507 crate::Pat::TupleStruct(v0: &PatTupleStruct) => crate::Pat::TupleStruct(v0.clone()),
1508 crate::Pat::Type(v0: &PatType) => crate::Pat::Type(v0.clone()),
1509 crate::Pat::Verbatim(v0: &TokenStream) => crate::Pat::Verbatim(v0.clone()),
1510 crate::Pat::Wild(v0: &PatWild) => crate::Pat::Wild(v0.clone()),
1511 }
1512 }
1513}
1514#[cfg(feature = "full")]
1515#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1516impl Clone for crate::PatIdent {
1517 fn clone(&self) -> Self {
1518 crate::PatIdent {
1519 attrs: self.attrs.clone(),
1520 by_ref: self.by_ref.clone(),
1521 mutability: self.mutability.clone(),
1522 ident: self.ident.clone(),
1523 subpat: self.subpat.clone(),
1524 }
1525 }
1526}
1527#[cfg(feature = "full")]
1528#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1529impl Clone for crate::PatOr {
1530 fn clone(&self) -> Self {
1531 crate::PatOr {
1532 attrs: self.attrs.clone(),
1533 leading_vert: self.leading_vert.clone(),
1534 cases: self.cases.clone(),
1535 }
1536 }
1537}
1538#[cfg(feature = "full")]
1539#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1540impl Clone for crate::PatParen {
1541 fn clone(&self) -> Self {
1542 crate::PatParen {
1543 attrs: self.attrs.clone(),
1544 paren_token: self.paren_token.clone(),
1545 pat: self.pat.clone(),
1546 }
1547 }
1548}
1549#[cfg(feature = "full")]
1550#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1551impl Clone for crate::PatReference {
1552 fn clone(&self) -> Self {
1553 crate::PatReference {
1554 attrs: self.attrs.clone(),
1555 and_token: self.and_token.clone(),
1556 mutability: self.mutability.clone(),
1557 pat: self.pat.clone(),
1558 }
1559 }
1560}
1561#[cfg(feature = "full")]
1562#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1563impl Clone for crate::PatRest {
1564 fn clone(&self) -> Self {
1565 crate::PatRest {
1566 attrs: self.attrs.clone(),
1567 dot2_token: self.dot2_token.clone(),
1568 }
1569 }
1570}
1571#[cfg(feature = "full")]
1572#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1573impl Clone for crate::PatSlice {
1574 fn clone(&self) -> Self {
1575 crate::PatSlice {
1576 attrs: self.attrs.clone(),
1577 bracket_token: self.bracket_token.clone(),
1578 elems: self.elems.clone(),
1579 }
1580 }
1581}
1582#[cfg(feature = "full")]
1583#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1584impl Clone for crate::PatStruct {
1585 fn clone(&self) -> Self {
1586 crate::PatStruct {
1587 attrs: self.attrs.clone(),
1588 qself: self.qself.clone(),
1589 path: self.path.clone(),
1590 brace_token: self.brace_token.clone(),
1591 fields: self.fields.clone(),
1592 rest: self.rest.clone(),
1593 }
1594 }
1595}
1596#[cfg(feature = "full")]
1597#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1598impl Clone for crate::PatTuple {
1599 fn clone(&self) -> Self {
1600 crate::PatTuple {
1601 attrs: self.attrs.clone(),
1602 paren_token: self.paren_token.clone(),
1603 elems: self.elems.clone(),
1604 }
1605 }
1606}
1607#[cfg(feature = "full")]
1608#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1609impl Clone for crate::PatTupleStruct {
1610 fn clone(&self) -> Self {
1611 crate::PatTupleStruct {
1612 attrs: self.attrs.clone(),
1613 qself: self.qself.clone(),
1614 path: self.path.clone(),
1615 paren_token: self.paren_token.clone(),
1616 elems: self.elems.clone(),
1617 }
1618 }
1619}
1620#[cfg(feature = "full")]
1621#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1622impl Clone for crate::PatType {
1623 fn clone(&self) -> Self {
1624 crate::PatType {
1625 attrs: self.attrs.clone(),
1626 pat: self.pat.clone(),
1627 colon_token: self.colon_token.clone(),
1628 ty: self.ty.clone(),
1629 }
1630 }
1631}
1632#[cfg(feature = "full")]
1633#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1634impl Clone for crate::PatWild {
1635 fn clone(&self) -> Self {
1636 crate::PatWild {
1637 attrs: self.attrs.clone(),
1638 underscore_token: self.underscore_token.clone(),
1639 }
1640 }
1641}
1642#[cfg(any(feature = "derive", feature = "full"))]
1643#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1644impl Clone for crate::Path {
1645 fn clone(&self) -> Self {
1646 crate::Path {
1647 leading_colon: self.leading_colon.clone(),
1648 segments: self.segments.clone(),
1649 }
1650 }
1651}
1652#[cfg(any(feature = "derive", feature = "full"))]
1653#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1654impl Clone for crate::PathArguments {
1655 fn clone(&self) -> Self {
1656 match self {
1657 crate::PathArguments::None => crate::PathArguments::None,
1658 crate::PathArguments::AngleBracketed(v0: &AngleBracketedGenericArguments) => {
1659 crate::PathArguments::AngleBracketed(v0.clone())
1660 }
1661 crate::PathArguments::Parenthesized(v0: &ParenthesizedGenericArguments) => {
1662 crate::PathArguments::Parenthesized(v0.clone())
1663 }
1664 }
1665 }
1666}
1667#[cfg(any(feature = "derive", feature = "full"))]
1668#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1669impl Clone for crate::PathSegment {
1670 fn clone(&self) -> Self {
1671 crate::PathSegment {
1672 ident: self.ident.clone(),
1673 arguments: self.arguments.clone(),
1674 }
1675 }
1676}
1677#[cfg(feature = "full")]
1678#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1679impl Clone for crate::PointerMutability {
1680 fn clone(&self) -> Self {
1681 match self {
1682 crate::PointerMutability::Const(v0: &Const) => {
1683 crate::PointerMutability::Const(v0.clone())
1684 }
1685 crate::PointerMutability::Mut(v0: &Mut) => {
1686 crate::PointerMutability::Mut(v0.clone())
1687 }
1688 }
1689 }
1690}
1691#[cfg(feature = "full")]
1692#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1693impl Clone for crate::PreciseCapture {
1694 fn clone(&self) -> Self {
1695 crate::PreciseCapture {
1696 use_token: self.use_token.clone(),
1697 lt_token: self.lt_token.clone(),
1698 params: self.params.clone(),
1699 gt_token: self.gt_token.clone(),
1700 }
1701 }
1702}
1703#[cfg(any(feature = "derive", feature = "full"))]
1704#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1705impl Clone for crate::PredicateLifetime {
1706 fn clone(&self) -> Self {
1707 crate::PredicateLifetime {
1708 lifetime: self.lifetime.clone(),
1709 colon_token: self.colon_token.clone(),
1710 bounds: self.bounds.clone(),
1711 }
1712 }
1713}
1714#[cfg(any(feature = "derive", feature = "full"))]
1715#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1716impl Clone for crate::PredicateType {
1717 fn clone(&self) -> Self {
1718 crate::PredicateType {
1719 lifetimes: self.lifetimes.clone(),
1720 bounded_ty: self.bounded_ty.clone(),
1721 colon_token: self.colon_token.clone(),
1722 bounds: self.bounds.clone(),
1723 }
1724 }
1725}
1726#[cfg(any(feature = "derive", feature = "full"))]
1727#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1728impl Clone for crate::QSelf {
1729 fn clone(&self) -> Self {
1730 crate::QSelf {
1731 lt_token: self.lt_token.clone(),
1732 ty: self.ty.clone(),
1733 position: self.position.clone(),
1734 as_token: self.as_token.clone(),
1735 gt_token: self.gt_token.clone(),
1736 }
1737 }
1738}
1739#[cfg(feature = "full")]
1740#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1741impl Copy for crate::RangeLimits {}
1742#[cfg(feature = "full")]
1743#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1744impl Clone for crate::RangeLimits {
1745 fn clone(&self) -> Self {
1746 *self
1747 }
1748}
1749#[cfg(feature = "full")]
1750#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1751impl Clone for crate::Receiver {
1752 fn clone(&self) -> Self {
1753 crate::Receiver {
1754 attrs: self.attrs.clone(),
1755 reference: self.reference.clone(),
1756 mutability: self.mutability.clone(),
1757 self_token: self.self_token.clone(),
1758 colon_token: self.colon_token.clone(),
1759 ty: self.ty.clone(),
1760 }
1761 }
1762}
1763#[cfg(any(feature = "derive", feature = "full"))]
1764#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1765impl Clone for crate::ReturnType {
1766 fn clone(&self) -> Self {
1767 match self {
1768 crate::ReturnType::Default => crate::ReturnType::Default,
1769 crate::ReturnType::Type(v0: &RArrow, v1: &Box) => {
1770 crate::ReturnType::Type(v0.clone(), v1.clone())
1771 }
1772 }
1773 }
1774}
1775#[cfg(feature = "full")]
1776#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1777impl Clone for crate::Signature {
1778 fn clone(&self) -> Self {
1779 crate::Signature {
1780 constness: self.constness.clone(),
1781 asyncness: self.asyncness.clone(),
1782 unsafety: self.unsafety.clone(),
1783 abi: self.abi.clone(),
1784 fn_token: self.fn_token.clone(),
1785 ident: self.ident.clone(),
1786 generics: self.generics.clone(),
1787 paren_token: self.paren_token.clone(),
1788 inputs: self.inputs.clone(),
1789 variadic: self.variadic.clone(),
1790 output: self.output.clone(),
1791 }
1792 }
1793}
1794#[cfg(feature = "full")]
1795#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1796impl Clone for crate::StaticMutability {
1797 fn clone(&self) -> Self {
1798 match self {
1799 crate::StaticMutability::Mut(v0: &Mut) => crate::StaticMutability::Mut(v0.clone()),
1800 crate::StaticMutability::None => crate::StaticMutability::None,
1801 }
1802 }
1803}
1804#[cfg(feature = "full")]
1805#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1806impl Clone for crate::Stmt {
1807 fn clone(&self) -> Self {
1808 match self {
1809 crate::Stmt::Local(v0: &Local) => crate::Stmt::Local(v0.clone()),
1810 crate::Stmt::Item(v0: &Item) => crate::Stmt::Item(v0.clone()),
1811 crate::Stmt::Expr(v0: &Expr, v1: &Option) => crate::Stmt::Expr(v0.clone(), v1.clone()),
1812 crate::Stmt::Macro(v0: &StmtMacro) => crate::Stmt::Macro(v0.clone()),
1813 }
1814 }
1815}
1816#[cfg(feature = "full")]
1817#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1818impl Clone for crate::StmtMacro {
1819 fn clone(&self) -> Self {
1820 crate::StmtMacro {
1821 attrs: self.attrs.clone(),
1822 mac: self.mac.clone(),
1823 semi_token: self.semi_token.clone(),
1824 }
1825 }
1826}
1827#[cfg(any(feature = "derive", feature = "full"))]
1828#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1829impl Clone for crate::TraitBound {
1830 fn clone(&self) -> Self {
1831 crate::TraitBound {
1832 paren_token: self.paren_token.clone(),
1833 modifier: self.modifier.clone(),
1834 lifetimes: self.lifetimes.clone(),
1835 path: self.path.clone(),
1836 }
1837 }
1838}
1839#[cfg(any(feature = "derive", feature = "full"))]
1840#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1841impl Copy for crate::TraitBoundModifier {}
1842#[cfg(any(feature = "derive", feature = "full"))]
1843#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1844impl Clone for crate::TraitBoundModifier {
1845 fn clone(&self) -> Self {
1846 *self
1847 }
1848}
1849#[cfg(feature = "full")]
1850#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1851impl Clone for crate::TraitItem {
1852 fn clone(&self) -> Self {
1853 match self {
1854 crate::TraitItem::Const(v0: &TraitItemConst) => crate::TraitItem::Const(v0.clone()),
1855 crate::TraitItem::Fn(v0: &TraitItemFn) => crate::TraitItem::Fn(v0.clone()),
1856 crate::TraitItem::Type(v0: &TraitItemType) => crate::TraitItem::Type(v0.clone()),
1857 crate::TraitItem::Macro(v0: &TraitItemMacro) => crate::TraitItem::Macro(v0.clone()),
1858 crate::TraitItem::Verbatim(v0: &TokenStream) => crate::TraitItem::Verbatim(v0.clone()),
1859 }
1860 }
1861}
1862#[cfg(feature = "full")]
1863#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1864impl Clone for crate::TraitItemConst {
1865 fn clone(&self) -> Self {
1866 crate::TraitItemConst {
1867 attrs: self.attrs.clone(),
1868 const_token: self.const_token.clone(),
1869 ident: self.ident.clone(),
1870 generics: self.generics.clone(),
1871 colon_token: self.colon_token.clone(),
1872 ty: self.ty.clone(),
1873 default: self.default.clone(),
1874 semi_token: self.semi_token.clone(),
1875 }
1876 }
1877}
1878#[cfg(feature = "full")]
1879#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1880impl Clone for crate::TraitItemFn {
1881 fn clone(&self) -> Self {
1882 crate::TraitItemFn {
1883 attrs: self.attrs.clone(),
1884 sig: self.sig.clone(),
1885 default: self.default.clone(),
1886 semi_token: self.semi_token.clone(),
1887 }
1888 }
1889}
1890#[cfg(feature = "full")]
1891#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1892impl Clone for crate::TraitItemMacro {
1893 fn clone(&self) -> Self {
1894 crate::TraitItemMacro {
1895 attrs: self.attrs.clone(),
1896 mac: self.mac.clone(),
1897 semi_token: self.semi_token.clone(),
1898 }
1899 }
1900}
1901#[cfg(feature = "full")]
1902#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1903impl Clone for crate::TraitItemType {
1904 fn clone(&self) -> Self {
1905 crate::TraitItemType {
1906 attrs: self.attrs.clone(),
1907 type_token: self.type_token.clone(),
1908 ident: self.ident.clone(),
1909 generics: self.generics.clone(),
1910 colon_token: self.colon_token.clone(),
1911 bounds: self.bounds.clone(),
1912 default: self.default.clone(),
1913 semi_token: self.semi_token.clone(),
1914 }
1915 }
1916}
1917#[cfg(any(feature = "derive", feature = "full"))]
1918#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1919impl Clone for crate::Type {
1920 fn clone(&self) -> Self {
1921 match self {
1922 crate::Type::Array(v0: &TypeArray) => crate::Type::Array(v0.clone()),
1923 crate::Type::BareFn(v0: &TypeBareFn) => crate::Type::BareFn(v0.clone()),
1924 crate::Type::Group(v0: &TypeGroup) => crate::Type::Group(v0.clone()),
1925 crate::Type::ImplTrait(v0: &TypeImplTrait) => crate::Type::ImplTrait(v0.clone()),
1926 crate::Type::Infer(v0: &TypeInfer) => crate::Type::Infer(v0.clone()),
1927 crate::Type::Macro(v0: &TypeMacro) => crate::Type::Macro(v0.clone()),
1928 crate::Type::Never(v0: &TypeNever) => crate::Type::Never(v0.clone()),
1929 crate::Type::Paren(v0: &TypeParen) => crate::Type::Paren(v0.clone()),
1930 crate::Type::Path(v0: &TypePath) => crate::Type::Path(v0.clone()),
1931 crate::Type::Ptr(v0: &TypePtr) => crate::Type::Ptr(v0.clone()),
1932 crate::Type::Reference(v0: &TypeReference) => crate::Type::Reference(v0.clone()),
1933 crate::Type::Slice(v0: &TypeSlice) => crate::Type::Slice(v0.clone()),
1934 crate::Type::TraitObject(v0: &TypeTraitObject) => crate::Type::TraitObject(v0.clone()),
1935 crate::Type::Tuple(v0: &TypeTuple) => crate::Type::Tuple(v0.clone()),
1936 crate::Type::Verbatim(v0: &TokenStream) => crate::Type::Verbatim(v0.clone()),
1937 }
1938 }
1939}
1940#[cfg(any(feature = "derive", feature = "full"))]
1941#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1942impl Clone for crate::TypeArray {
1943 fn clone(&self) -> Self {
1944 crate::TypeArray {
1945 bracket_token: self.bracket_token.clone(),
1946 elem: self.elem.clone(),
1947 semi_token: self.semi_token.clone(),
1948 len: self.len.clone(),
1949 }
1950 }
1951}
1952#[cfg(any(feature = "derive", feature = "full"))]
1953#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1954impl Clone for crate::TypeBareFn {
1955 fn clone(&self) -> Self {
1956 crate::TypeBareFn {
1957 lifetimes: self.lifetimes.clone(),
1958 unsafety: self.unsafety.clone(),
1959 abi: self.abi.clone(),
1960 fn_token: self.fn_token.clone(),
1961 paren_token: self.paren_token.clone(),
1962 inputs: self.inputs.clone(),
1963 variadic: self.variadic.clone(),
1964 output: self.output.clone(),
1965 }
1966 }
1967}
1968#[cfg(any(feature = "derive", feature = "full"))]
1969#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1970impl Clone for crate::TypeGroup {
1971 fn clone(&self) -> Self {
1972 crate::TypeGroup {
1973 group_token: self.group_token.clone(),
1974 elem: self.elem.clone(),
1975 }
1976 }
1977}
1978#[cfg(any(feature = "derive", feature = "full"))]
1979#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1980impl Clone for crate::TypeImplTrait {
1981 fn clone(&self) -> Self {
1982 crate::TypeImplTrait {
1983 impl_token: self.impl_token.clone(),
1984 bounds: self.bounds.clone(),
1985 }
1986 }
1987}
1988#[cfg(any(feature = "derive", feature = "full"))]
1989#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1990impl Clone for crate::TypeInfer {
1991 fn clone(&self) -> Self {
1992 crate::TypeInfer {
1993 underscore_token: self.underscore_token.clone(),
1994 }
1995 }
1996}
1997#[cfg(any(feature = "derive", feature = "full"))]
1998#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1999impl Clone for crate::TypeMacro {
2000 fn clone(&self) -> Self {
2001 crate::TypeMacro {
2002 mac: self.mac.clone(),
2003 }
2004 }
2005}
2006#[cfg(any(feature = "derive", feature = "full"))]
2007#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2008impl Clone for crate::TypeNever {
2009 fn clone(&self) -> Self {
2010 crate::TypeNever {
2011 bang_token: self.bang_token.clone(),
2012 }
2013 }
2014}
2015#[cfg(any(feature = "derive", feature = "full"))]
2016#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2017impl Clone for crate::TypeParam {
2018 fn clone(&self) -> Self {
2019 crate::TypeParam {
2020 attrs: self.attrs.clone(),
2021 ident: self.ident.clone(),
2022 colon_token: self.colon_token.clone(),
2023 bounds: self.bounds.clone(),
2024 eq_token: self.eq_token.clone(),
2025 default: self.default.clone(),
2026 }
2027 }
2028}
2029#[cfg(any(feature = "derive", feature = "full"))]
2030#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2031impl Clone for crate::TypeParamBound {
2032 fn clone(&self) -> Self {
2033 match self {
2034 crate::TypeParamBound::Trait(v0: &TraitBound) => crate::TypeParamBound::Trait(v0.clone()),
2035 crate::TypeParamBound::Lifetime(v0: &Lifetime) => {
2036 crate::TypeParamBound::Lifetime(v0.clone())
2037 }
2038 #[cfg(feature = "full")]
2039 crate::TypeParamBound::PreciseCapture(v0: &PreciseCapture) => {
2040 crate::TypeParamBound::PreciseCapture(v0.clone())
2041 }
2042 crate::TypeParamBound::Verbatim(v0: &TokenStream) => {
2043 crate::TypeParamBound::Verbatim(v0.clone())
2044 }
2045 #[cfg(not(feature = "full"))]
2046 _ => unreachable!(),
2047 }
2048 }
2049}
2050#[cfg(any(feature = "derive", feature = "full"))]
2051#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2052impl Clone for crate::TypeParen {
2053 fn clone(&self) -> Self {
2054 crate::TypeParen {
2055 paren_token: self.paren_token.clone(),
2056 elem: self.elem.clone(),
2057 }
2058 }
2059}
2060#[cfg(any(feature = "derive", feature = "full"))]
2061#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2062impl Clone for crate::TypePath {
2063 fn clone(&self) -> Self {
2064 crate::TypePath {
2065 qself: self.qself.clone(),
2066 path: self.path.clone(),
2067 }
2068 }
2069}
2070#[cfg(any(feature = "derive", feature = "full"))]
2071#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2072impl Clone for crate::TypePtr {
2073 fn clone(&self) -> Self {
2074 crate::TypePtr {
2075 star_token: self.star_token.clone(),
2076 const_token: self.const_token.clone(),
2077 mutability: self.mutability.clone(),
2078 elem: self.elem.clone(),
2079 }
2080 }
2081}
2082#[cfg(any(feature = "derive", feature = "full"))]
2083#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2084impl Clone for crate::TypeReference {
2085 fn clone(&self) -> Self {
2086 crate::TypeReference {
2087 and_token: self.and_token.clone(),
2088 lifetime: self.lifetime.clone(),
2089 mutability: self.mutability.clone(),
2090 elem: self.elem.clone(),
2091 }
2092 }
2093}
2094#[cfg(any(feature = "derive", feature = "full"))]
2095#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2096impl Clone for crate::TypeSlice {
2097 fn clone(&self) -> Self {
2098 crate::TypeSlice {
2099 bracket_token: self.bracket_token.clone(),
2100 elem: self.elem.clone(),
2101 }
2102 }
2103}
2104#[cfg(any(feature = "derive", feature = "full"))]
2105#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2106impl Clone for crate::TypeTraitObject {
2107 fn clone(&self) -> Self {
2108 crate::TypeTraitObject {
2109 dyn_token: self.dyn_token.clone(),
2110 bounds: self.bounds.clone(),
2111 }
2112 }
2113}
2114#[cfg(any(feature = "derive", feature = "full"))]
2115#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2116impl Clone for crate::TypeTuple {
2117 fn clone(&self) -> Self {
2118 crate::TypeTuple {
2119 paren_token: self.paren_token.clone(),
2120 elems: self.elems.clone(),
2121 }
2122 }
2123}
2124#[cfg(any(feature = "derive", feature = "full"))]
2125#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2126impl Copy for crate::UnOp {}
2127#[cfg(any(feature = "derive", feature = "full"))]
2128#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2129impl Clone for crate::UnOp {
2130 fn clone(&self) -> Self {
2131 *self
2132 }
2133}
2134#[cfg(feature = "full")]
2135#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2136impl Clone for crate::UseGlob {
2137 fn clone(&self) -> Self {
2138 crate::UseGlob {
2139 star_token: self.star_token.clone(),
2140 }
2141 }
2142}
2143#[cfg(feature = "full")]
2144#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2145impl Clone for crate::UseGroup {
2146 fn clone(&self) -> Self {
2147 crate::UseGroup {
2148 brace_token: self.brace_token.clone(),
2149 items: self.items.clone(),
2150 }
2151 }
2152}
2153#[cfg(feature = "full")]
2154#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2155impl Clone for crate::UseName {
2156 fn clone(&self) -> Self {
2157 crate::UseName {
2158 ident: self.ident.clone(),
2159 }
2160 }
2161}
2162#[cfg(feature = "full")]
2163#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2164impl Clone for crate::UsePath {
2165 fn clone(&self) -> Self {
2166 crate::UsePath {
2167 ident: self.ident.clone(),
2168 colon2_token: self.colon2_token.clone(),
2169 tree: self.tree.clone(),
2170 }
2171 }
2172}
2173#[cfg(feature = "full")]
2174#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2175impl Clone for crate::UseRename {
2176 fn clone(&self) -> Self {
2177 crate::UseRename {
2178 ident: self.ident.clone(),
2179 as_token: self.as_token.clone(),
2180 rename: self.rename.clone(),
2181 }
2182 }
2183}
2184#[cfg(feature = "full")]
2185#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2186impl Clone for crate::UseTree {
2187 fn clone(&self) -> Self {
2188 match self {
2189 crate::UseTree::Path(v0: &UsePath) => crate::UseTree::Path(v0.clone()),
2190 crate::UseTree::Name(v0: &UseName) => crate::UseTree::Name(v0.clone()),
2191 crate::UseTree::Rename(v0: &UseRename) => crate::UseTree::Rename(v0.clone()),
2192 crate::UseTree::Glob(v0: &UseGlob) => crate::UseTree::Glob(v0.clone()),
2193 crate::UseTree::Group(v0: &UseGroup) => crate::UseTree::Group(v0.clone()),
2194 }
2195 }
2196}
2197#[cfg(feature = "full")]
2198#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2199impl Clone for crate::Variadic {
2200 fn clone(&self) -> Self {
2201 crate::Variadic {
2202 attrs: self.attrs.clone(),
2203 pat: self.pat.clone(),
2204 dots: self.dots.clone(),
2205 comma: self.comma.clone(),
2206 }
2207 }
2208}
2209#[cfg(any(feature = "derive", feature = "full"))]
2210#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2211impl Clone for crate::Variant {
2212 fn clone(&self) -> Self {
2213 crate::Variant {
2214 attrs: self.attrs.clone(),
2215 ident: self.ident.clone(),
2216 fields: self.fields.clone(),
2217 discriminant: self.discriminant.clone(),
2218 }
2219 }
2220}
2221#[cfg(any(feature = "derive", feature = "full"))]
2222#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2223impl Clone for crate::VisRestricted {
2224 fn clone(&self) -> Self {
2225 crate::VisRestricted {
2226 pub_token: self.pub_token.clone(),
2227 paren_token: self.paren_token.clone(),
2228 in_token: self.in_token.clone(),
2229 path: self.path.clone(),
2230 }
2231 }
2232}
2233#[cfg(any(feature = "derive", feature = "full"))]
2234#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2235impl Clone for crate::Visibility {
2236 fn clone(&self) -> Self {
2237 match self {
2238 crate::Visibility::Public(v0: &Pub) => crate::Visibility::Public(v0.clone()),
2239 crate::Visibility::Restricted(v0: &VisRestricted) => {
2240 crate::Visibility::Restricted(v0.clone())
2241 }
2242 crate::Visibility::Inherited => crate::Visibility::Inherited,
2243 }
2244 }
2245}
2246#[cfg(any(feature = "derive", feature = "full"))]
2247#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2248impl Clone for crate::WhereClause {
2249 fn clone(&self) -> Self {
2250 crate::WhereClause {
2251 where_token: self.where_token.clone(),
2252 predicates: self.predicates.clone(),
2253 }
2254 }
2255}
2256#[cfg(any(feature = "derive", feature = "full"))]
2257#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2258impl Clone for crate::WherePredicate {
2259 fn clone(&self) -> Self {
2260 match self {
2261 crate::WherePredicate::Lifetime(v0: &PredicateLifetime) => {
2262 crate::WherePredicate::Lifetime(v0.clone())
2263 }
2264 crate::WherePredicate::Type(v0: &PredicateType) => crate::WherePredicate::Type(v0.clone()),
2265 }
2266 }
2267}
2268