Debian Codegraph @

rust/syn/gen/clone.rs

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