1#![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 fat_arrow_token: self.fat_arrow_token.clone(),
35 body: self.body.clone(),
36 comma: self.comma.clone(),
37 }
38 }
39}
40#[cfg(any(feature = "derive", feature = "full"))]
41#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
42impl Clone for crate::AssocConst {
43 fn clone(&self) -> Self {
44 crate::AssocConst {
45 ident: self.ident.clone(),
46 generics: self.generics.clone(),
47 eq_token: self.eq_token.clone(),
48 value: self.value.clone(),
49 }
50 }
51}
52#[cfg(any(feature = "derive", feature = "full"))]
53#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
54impl Clone for crate::AssocType {
55 fn clone(&self) -> Self {
56 crate::AssocType {
57 ident: self.ident.clone(),
58 generics: self.generics.clone(),
59 eq_token: self.eq_token.clone(),
60 ty: self.ty.clone(),
61 }
62 }
63}
64#[cfg(any(feature = "derive", feature = "full"))]
65#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
66impl Copy for crate::AttrStyle {}
67#[cfg(any(feature = "derive", feature = "full"))]
68#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
69impl Clone for crate::AttrStyle {
70 fn clone(&self) -> Self {
71 *self
72 }
73}
74#[cfg(any(feature = "derive", feature = "full"))]
75#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
76impl Clone for crate::Attribute {
77 fn clone(&self) -> Self {
78 crate::Attribute {
79 pound_token: self.pound_token.clone(),
80 style: self.style.clone(),
81 bracket_token: self.bracket_token.clone(),
82 meta: self.meta.clone(),
83 }
84 }
85}
86#[cfg(any(feature = "derive", feature = "full"))]
87#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
88impl Copy for crate::BinOp {}
89#[cfg(any(feature = "derive", feature = "full"))]
90#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
91impl Clone for crate::BinOp {
92 fn clone(&self) -> Self {
93 *self
94 }
95}
96#[cfg(feature = "full")]
97#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
98impl Clone for crate::Block {
99 fn clone(&self) -> Self {
100 crate::Block {
101 brace_token: self.brace_token.clone(),
102 stmts: self.stmts.clone(),
103 }
104 }
105}
106#[cfg(feature = "full")]
107#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
108impl Clone for crate::BlockModifiers {
109 fn clone(&self) -> Self {
110 crate::BlockModifiers {}
111 }
112}
113#[cfg(any(feature = "derive", feature = "full"))]
114#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
115impl Clone for crate::BoundLifetimes {
116 fn clone(&self) -> Self {
117 crate::BoundLifetimes {
118 for_token: self.for_token.clone(),
119 lt_token: self.lt_token.clone(),
120 lifetimes: self.lifetimes.clone(),
121 gt_token: self.gt_token.clone(),
122 }
123 }
124}
125#[cfg(feature = "full")]
126#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
127impl Clone for crate::CapturedParam {
128 fn clone(&self) -> Self {
129 match self {
130 crate::CapturedParam::Lifetime(v0) => {
131 crate::CapturedParam::Lifetime(v0.clone())
132 }
133 crate::CapturedParam::Ident(v0) => crate::CapturedParam::Ident(v0.clone()),
134 }
135 }
136}
137#[cfg(feature = "full")]
138#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
139impl Clone for crate::ClosureModifiers {
140 fn clone(&self) -> Self {
141 crate::ClosureModifiers {}
142 }
143}
144#[cfg(feature = "full")]
145#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
146impl Clone for crate::ConstModifiers {
147 fn clone(&self) -> Self {
148 crate::ConstModifiers {
149 defaultness: self.defaultness.clone(),
150 }
151 }
152}
153#[cfg(any(feature = "derive", feature = "full"))]
154#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
155impl Clone for crate::ConstParam {
156 fn clone(&self) -> Self {
157 crate::ConstParam {
158 attrs: self.attrs.clone(),
159 const_token: self.const_token.clone(),
160 ident: self.ident.clone(),
161 colon_token: self.colon_token.clone(),
162 ty: self.ty.clone(),
163 default: self.default.clone(),
164 }
165 }
166}
167#[cfg(any(feature = "derive", feature = "full"))]
168#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
169impl Clone for crate::Constraint {
170 fn clone(&self) -> Self {
171 crate::Constraint {
172 ident: self.ident.clone(),
173 generics: self.generics.clone(),
174 colon_token: self.colon_token.clone(),
175 bounds: self.bounds.clone(),
176 }
177 }
178}
179#[cfg(feature = "derive")]
180#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
181impl Clone for crate::Data {
182 fn clone(&self) -> Self {
183 match self {
184 crate::Data::Struct(v0) => crate::Data::Struct(v0.clone()),
185 crate::Data::Enum(v0) => crate::Data::Enum(v0.clone()),
186 crate::Data::Union(v0) => crate::Data::Union(v0.clone()),
187 }
188 }
189}
190#[cfg(feature = "derive")]
191#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
192impl Clone for crate::DataEnum {
193 fn clone(&self) -> Self {
194 crate::DataEnum {
195 enum_token: self.enum_token.clone(),
196 brace_token: self.brace_token.clone(),
197 variants: self.variants.clone(),
198 }
199 }
200}
201#[cfg(feature = "derive")]
202#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
203impl Clone for crate::DataStruct {
204 fn clone(&self) -> Self {
205 crate::DataStruct {
206 struct_token: self.struct_token.clone(),
207 fields: self.fields.clone(),
208 semi_token: self.semi_token.clone(),
209 }
210 }
211}
212#[cfg(feature = "derive")]
213#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
214impl Clone for crate::DataUnion {
215 fn clone(&self) -> Self {
216 crate::DataUnion {
217 union_token: self.union_token.clone(),
218 fields: self.fields.clone(),
219 }
220 }
221}
222#[cfg(feature = "derive")]
223#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
224impl Clone for crate::DeriveInput {
225 fn clone(&self) -> Self {
226 crate::DeriveInput {
227 attrs: self.attrs.clone(),
228 vis: self.vis.clone(),
229 ident: self.ident.clone(),
230 generics: self.generics.clone(),
231 data: self.data.clone(),
232 }
233 }
234}
235#[cfg(any(feature = "derive", feature = "full"))]
236#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
237impl Clone for crate::Expr {
238 fn clone(&self) -> Self {
239 match self {
240 #[cfg(feature = "full")]
241 crate::Expr::Array(v0) => crate::Expr::Array(v0.clone()),
242 #[cfg(feature = "full")]
243 crate::Expr::Assign(v0) => crate::Expr::Assign(v0.clone()),
244 #[cfg(feature = "full")]
245 crate::Expr::Async(v0) => crate::Expr::Async(v0.clone()),
246 #[cfg(feature = "full")]
247 crate::Expr::Await(v0) => crate::Expr::Await(v0.clone()),
248 crate::Expr::Binary(v0) => crate::Expr::Binary(v0.clone()),
249 #[cfg(feature = "full")]
250 crate::Expr::Block(v0) => crate::Expr::Block(v0.clone()),
251 #[cfg(feature = "full")]
252 crate::Expr::Break(v0) => crate::Expr::Break(v0.clone()),
253 crate::Expr::Call(v0) => crate::Expr::Call(v0.clone()),
254 crate::Expr::Cast(v0) => crate::Expr::Cast(v0.clone()),
255 #[cfg(feature = "full")]
256 crate::Expr::Closure(v0) => crate::Expr::Closure(v0.clone()),
257 #[cfg(feature = "full")]
258 crate::Expr::Const(v0) => crate::Expr::Const(v0.clone()),
259 #[cfg(feature = "full")]
260 crate::Expr::Continue(v0) => crate::Expr::Continue(v0.clone()),
261 crate::Expr::Field(v0) => crate::Expr::Field(v0.clone()),
262 #[cfg(feature = "full")]
263 crate::Expr::ForLoop(v0) => crate::Expr::ForLoop(v0.clone()),
264 crate::Expr::Group(v0) => crate::Expr::Group(v0.clone()),
265 #[cfg(feature = "full")]
266 crate::Expr::If(v0) => crate::Expr::If(v0.clone()),
267 crate::Expr::Index(v0) => crate::Expr::Index(v0.clone()),
268 #[cfg(feature = "full")]
269 crate::Expr::Infer(v0) => crate::Expr::Infer(v0.clone()),
270 #[cfg(feature = "full")]
271 crate::Expr::Let(v0) => crate::Expr::Let(v0.clone()),
272 crate::Expr::Lit(v0) => crate::Expr::Lit(v0.clone()),
273 #[cfg(feature = "full")]
274 crate::Expr::Loop(v0) => crate::Expr::Loop(v0.clone()),
275 crate::Expr::Macro(v0) => crate::Expr::Macro(v0.clone()),
276 #[cfg(feature = "full")]
277 crate::Expr::Match(v0) => crate::Expr::Match(v0.clone()),
278 crate::Expr::MethodCall(v0) => crate::Expr::MethodCall(v0.clone()),
279 crate::Expr::Paren(v0) => crate::Expr::Paren(v0.clone()),
280 crate::Expr::Path(v0) => crate::Expr::Path(v0.clone()),
281 #[cfg(feature = "full")]
282 crate::Expr::Range(v0) => crate::Expr::Range(v0.clone()),
283 #[cfg(feature = "full")]
284 crate::Expr::RawAddr(v0) => crate::Expr::RawAddr(v0.clone()),
285 crate::Expr::Reference(v0) => crate::Expr::Reference(v0.clone()),
286 #[cfg(feature = "full")]
287 crate::Expr::Repeat(v0) => crate::Expr::Repeat(v0.clone()),
288 #[cfg(feature = "full")]
289 crate::Expr::Return(v0) => crate::Expr::Return(v0.clone()),
290 crate::Expr::Struct(v0) => crate::Expr::Struct(v0.clone()),
291 #[cfg(feature = "full")]
292 crate::Expr::Try(v0) => crate::Expr::Try(v0.clone()),
293 #[cfg(feature = "full")]
294 crate::Expr::TryBlock(v0) => crate::Expr::TryBlock(v0.clone()),
295 crate::Expr::Tuple(v0) => crate::Expr::Tuple(v0.clone()),
296 crate::Expr::Unary(v0) => crate::Expr::Unary(v0.clone()),
297 #[cfg(feature = "full")]
298 crate::Expr::Unsafe(v0) => crate::Expr::Unsafe(v0.clone()),
299 crate::Expr::Verbatim(v0) => crate::Expr::Verbatim(v0.clone()),
300 #[cfg(feature = "full")]
301 crate::Expr::While(v0) => crate::Expr::While(v0.clone()),
302 #[cfg(feature = "full")]
303 crate::Expr::Yield(v0) => crate::Expr::Yield(v0.clone()),
304 #[cfg(not(feature = "full"))]
305 _ => unreachable!(),
306 }
307 }
308}
309#[cfg(feature = "full")]
310#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
311impl Clone for crate::ExprArray {
312 fn clone(&self) -> Self {
313 crate::ExprArray {
314 attrs: self.attrs.clone(),
315 bracket_token: self.bracket_token.clone(),
316 elems: self.elems.clone(),
317 }
318 }
319}
320#[cfg(feature = "full")]
321#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
322impl Clone for crate::ExprAssign {
323 fn clone(&self) -> Self {
324 crate::ExprAssign {
325 attrs: self.attrs.clone(),
326 left: self.left.clone(),
327 eq_token: self.eq_token.clone(),
328 right: self.right.clone(),
329 }
330 }
331}
332#[cfg(feature = "full")]
333#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
334impl Clone for crate::ExprAsync {
335 fn clone(&self) -> Self {
336 crate::ExprAsync {
337 attrs: self.attrs.clone(),
338 async_token: self.async_token.clone(),
339 capture: self.capture.clone(),
340 modifiers: self.modifiers.clone(),
341 block: self.block.clone(),
342 }
343 }
344}
345#[cfg(feature = "full")]
346#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
347impl Clone for crate::ExprAwait {
348 fn clone(&self) -> Self {
349 crate::ExprAwait {
350 attrs: self.attrs.clone(),
351 base: self.base.clone(),
352 dot_token: self.dot_token.clone(),
353 await_token: self.await_token.clone(),
354 }
355 }
356}
357#[cfg(any(feature = "derive", feature = "full"))]
358#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
359impl Clone for crate::ExprBinary {
360 fn clone(&self) -> Self {
361 crate::ExprBinary {
362 attrs: self.attrs.clone(),
363 left: self.left.clone(),
364 op: self.op.clone(),
365 right: self.right.clone(),
366 }
367 }
368}
369#[cfg(feature = "full")]
370#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
371impl Clone for crate::ExprBlock {
372 fn clone(&self) -> Self {
373 crate::ExprBlock {
374 attrs: self.attrs.clone(),
375 label: self.label.clone(),
376 block: self.block.clone(),
377 }
378 }
379}
380#[cfg(feature = "full")]
381#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
382impl Clone for crate::ExprBreak {
383 fn clone(&self) -> Self {
384 crate::ExprBreak {
385 attrs: self.attrs.clone(),
386 break_token: self.break_token.clone(),
387 label: self.label.clone(),
388 expr: self.expr.clone(),
389 }
390 }
391}
392#[cfg(any(feature = "derive", feature = "full"))]
393#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
394impl Clone for crate::ExprCall {
395 fn clone(&self) -> Self {
396 crate::ExprCall {
397 attrs: self.attrs.clone(),
398 func: self.func.clone(),
399 paren_token: self.paren_token.clone(),
400 args: self.args.clone(),
401 }
402 }
403}
404#[cfg(any(feature = "derive", feature = "full"))]
405#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
406impl Clone for crate::ExprCast {
407 fn clone(&self) -> Self {
408 crate::ExprCast {
409 attrs: self.attrs.clone(),
410 expr: self.expr.clone(),
411 as_token: self.as_token.clone(),
412 ty: self.ty.clone(),
413 }
414 }
415}
416#[cfg(feature = "full")]
417#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
418impl Clone for crate::ExprClosure {
419 fn clone(&self) -> Self {
420 crate::ExprClosure {
421 attrs: self.attrs.clone(),
422 lifetimes: self.lifetimes.clone(),
423 modifiers: self.modifiers.clone(),
424 constness: self.constness.clone(),
425 asyncness: self.asyncness.clone(),
426 capture: self.capture.clone(),
427 inputs_begin: self.inputs_begin.clone(),
428 inputs: self.inputs.clone(),
429 inputs_end: self.inputs_end.clone(),
430 output: self.output.clone(),
431 body: self.body.clone(),
432 }
433 }
434}
435#[cfg(feature = "full")]
436#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
437impl Clone for crate::ExprConst {
438 fn clone(&self) -> Self {
439 crate::ExprConst {
440 attrs: self.attrs.clone(),
441 const_token: self.const_token.clone(),
442 modifiers: self.modifiers.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 modifiers: self.modifiers.clone(),
721 block: self.block.clone(),
722 }
723 }
724}
725#[cfg(any(feature = "derive", feature = "full"))]
726#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
727impl Clone for crate::ExprTuple {
728 fn clone(&self) -> Self {
729 crate::ExprTuple {
730 attrs: self.attrs.clone(),
731 paren_token: self.paren_token.clone(),
732 elems: self.elems.clone(),
733 }
734 }
735}
736#[cfg(any(feature = "derive", feature = "full"))]
737#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
738impl Clone for crate::ExprUnary {
739 fn clone(&self) -> Self {
740 crate::ExprUnary {
741 attrs: self.attrs.clone(),
742 op: self.op.clone(),
743 expr: self.expr.clone(),
744 }
745 }
746}
747#[cfg(feature = "full")]
748#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
749impl Clone for crate::ExprUnsafe {
750 fn clone(&self) -> Self {
751 crate::ExprUnsafe {
752 attrs: self.attrs.clone(),
753 unsafe_token: self.unsafe_token.clone(),
754 block: self.block.clone(),
755 }
756 }
757}
758#[cfg(feature = "full")]
759#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
760impl Clone for crate::ExprWhile {
761 fn clone(&self) -> Self {
762 crate::ExprWhile {
763 attrs: self.attrs.clone(),
764 label: self.label.clone(),
765 while_token: self.while_token.clone(),
766 cond: self.cond.clone(),
767 body: self.body.clone(),
768 }
769 }
770}
771#[cfg(feature = "full")]
772#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
773impl Clone for crate::ExprYield {
774 fn clone(&self) -> Self {
775 crate::ExprYield {
776 attrs: self.attrs.clone(),
777 yield_token: self.yield_token.clone(),
778 expr: self.expr.clone(),
779 }
780 }
781}
782#[cfg(any(feature = "derive", feature = "full"))]
783#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
784impl Clone for crate::Field {
785 fn clone(&self) -> Self {
786 crate::Field {
787 attrs: self.attrs.clone(),
788 vis: self.vis.clone(),
789 modifiers: self.modifiers.clone(),
790 ident: self.ident.clone(),
791 colon_token: self.colon_token.clone(),
792 ty: self.ty.clone(),
793 default: self.default.clone(),
794 }
795 }
796}
797#[cfg(any(feature = "derive", feature = "full"))]
798#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
799impl Clone for crate::FieldModifiers {
800 fn clone(&self) -> Self {
801 crate::FieldModifiers {}
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) => crate::Fields::Named(v0.clone()),
834 crate::Fields::Unnamed(v0) => 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 frontmatter: self.frontmatter.clone(),
866 attrs: self.attrs.clone(),
867 items: self.items.clone(),
868 }
869 }
870}
871#[cfg(feature = "full")]
872#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
873impl Clone for crate::FnArg {
874 fn clone(&self) -> Self {
875 match self {
876 crate::FnArg::Receiver(v0) => crate::FnArg::Receiver(v0.clone()),
877 crate::FnArg::Typed(v0) => crate::FnArg::Typed(v0.clone()),
878 }
879 }
880}
881#[cfg(feature = "full")]
882#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
883impl Clone for crate::FnModifiers {
884 fn clone(&self) -> Self {
885 crate::FnModifiers {
886 defaultness: self.defaultness.clone(),
887 }
888 }
889}
890#[cfg(any(feature = "derive", feature = "full"))]
891#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
892impl Clone for crate::FnPtrVariadic {
893 fn clone(&self) -> Self {
894 crate::FnPtrVariadic {
895 attrs: self.attrs.clone(),
896 name: self.name.clone(),
897 dots: self.dots.clone(),
898 comma: self.comma.clone(),
899 }
900 }
901}
902#[cfg(feature = "full")]
903#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
904impl Clone for crate::ForeignItem {
905 fn clone(&self) -> Self {
906 match self {
907 crate::ForeignItem::Fn(v0) => crate::ForeignItem::Fn(v0.clone()),
908 crate::ForeignItem::Static(v0) => crate::ForeignItem::Static(v0.clone()),
909 crate::ForeignItem::Type(v0) => crate::ForeignItem::Type(v0.clone()),
910 crate::ForeignItem::Macro(v0) => crate::ForeignItem::Macro(v0.clone()),
911 crate::ForeignItem::Verbatim(v0) => crate::ForeignItem::Verbatim(v0.clone()),
912 }
913 }
914}
915#[cfg(feature = "full")]
916#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
917impl Clone for crate::ForeignItemFn {
918 fn clone(&self) -> Self {
919 crate::ForeignItemFn {
920 attrs: self.attrs.clone(),
921 vis: self.vis.clone(),
922 modifiers: self.modifiers.clone(),
923 sig: self.sig.clone(),
924 semi_token: self.semi_token.clone(),
925 }
926 }
927}
928#[cfg(feature = "full")]
929#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
930impl Clone for crate::ForeignItemMacro {
931 fn clone(&self) -> Self {
932 crate::ForeignItemMacro {
933 attrs: self.attrs.clone(),
934 mac: self.mac.clone(),
935 semi_token: self.semi_token.clone(),
936 }
937 }
938}
939#[cfg(feature = "full")]
940#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
941impl Clone for crate::ForeignItemStatic {
942 fn clone(&self) -> Self {
943 crate::ForeignItemStatic {
944 attrs: self.attrs.clone(),
945 vis: self.vis.clone(),
946 safety: self.safety.clone(),
947 static_token: self.static_token.clone(),
948 mutability: self.mutability.clone(),
949 ident: self.ident.clone(),
950 colon_token: self.colon_token.clone(),
951 ty: self.ty.clone(),
952 semi_token: self.semi_token.clone(),
953 }
954 }
955}
956#[cfg(feature = "full")]
957#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
958impl Clone for crate::ForeignItemType {
959 fn clone(&self) -> Self {
960 crate::ForeignItemType {
961 attrs: self.attrs.clone(),
962 vis: self.vis.clone(),
963 modifiers: self.modifiers.clone(),
964 type_token: self.type_token.clone(),
965 ident: self.ident.clone(),
966 generics: self.generics.clone(),
967 semi_token: self.semi_token.clone(),
968 }
969 }
970}
971#[cfg(feature = "full")]
972#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
973impl Clone for crate::Frontmatter {
974 fn clone(&self) -> Self {
975 crate::Frontmatter {}
976 }
977}
978#[cfg(any(feature = "derive", feature = "full"))]
979#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
980impl Clone for crate::GenericArgument {
981 fn clone(&self) -> Self {
982 match self {
983 crate::GenericArgument::Lifetime(v0) => {
984 crate::GenericArgument::Lifetime(v0.clone())
985 }
986 crate::GenericArgument::Type(v0) => crate::GenericArgument::Type(v0.clone()),
987 crate::GenericArgument::Const(v0) => {
988 crate::GenericArgument::Const(v0.clone())
989 }
990 crate::GenericArgument::AssocType(v0) => {
991 crate::GenericArgument::AssocType(v0.clone())
992 }
993 crate::GenericArgument::AssocConst(v0) => {
994 crate::GenericArgument::AssocConst(v0.clone())
995 }
996 crate::GenericArgument::Constraint(v0) => {
997 crate::GenericArgument::Constraint(v0.clone())
998 }
999 }
1000 }
1001}
1002#[cfg(any(feature = "derive", feature = "full"))]
1003#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1004impl Clone for crate::GenericParam {
1005 fn clone(&self) -> Self {
1006 match self {
1007 crate::GenericParam::Lifetime(v0) => {
1008 crate::GenericParam::Lifetime(v0.clone())
1009 }
1010 crate::GenericParam::Type(v0) => crate::GenericParam::Type(v0.clone()),
1011 crate::GenericParam::Const(v0) => crate::GenericParam::Const(v0.clone()),
1012 }
1013 }
1014}
1015#[cfg(any(feature = "derive", feature = "full"))]
1016#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1017impl Clone for crate::Generics {
1018 fn clone(&self) -> Self {
1019 crate::Generics {
1020 lt_token: self.lt_token.clone(),
1021 params: self.params.clone(),
1022 gt_token: self.gt_token.clone(),
1023 where_clause: self.where_clause.clone(),
1024 }
1025 }
1026}
1027#[cfg(feature = "full")]
1028#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1029impl Clone for crate::ImplItem {
1030 fn clone(&self) -> Self {
1031 match self {
1032 crate::ImplItem::Const(v0) => crate::ImplItem::Const(v0.clone()),
1033 crate::ImplItem::Fn(v0) => crate::ImplItem::Fn(v0.clone()),
1034 crate::ImplItem::Type(v0) => crate::ImplItem::Type(v0.clone()),
1035 crate::ImplItem::Macro(v0) => crate::ImplItem::Macro(v0.clone()),
1036 crate::ImplItem::Verbatim(v0) => crate::ImplItem::Verbatim(v0.clone()),
1037 }
1038 }
1039}
1040#[cfg(feature = "full")]
1041#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1042impl Clone for crate::ImplItemConst {
1043 fn clone(&self) -> Self {
1044 crate::ImplItemConst {
1045 attrs: self.attrs.clone(),
1046 vis: self.vis.clone(),
1047 modifiers: self.modifiers.clone(),
1048 const_token: self.const_token.clone(),
1049 ident: self.ident.clone(),
1050 generics: self.generics.clone(),
1051 colon_token: self.colon_token.clone(),
1052 ty: self.ty.clone(),
1053 eq_token: self.eq_token.clone(),
1054 expr: self.expr.clone(),
1055 semi_token: self.semi_token.clone(),
1056 }
1057 }
1058}
1059#[cfg(feature = "full")]
1060#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1061impl Clone for crate::ImplItemFn {
1062 fn clone(&self) -> Self {
1063 crate::ImplItemFn {
1064 attrs: self.attrs.clone(),
1065 vis: self.vis.clone(),
1066 modifiers: self.modifiers.clone(),
1067 sig: self.sig.clone(),
1068 block: self.block.clone(),
1069 }
1070 }
1071}
1072#[cfg(feature = "full")]
1073#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1074impl Clone for crate::ImplItemMacro {
1075 fn clone(&self) -> Self {
1076 crate::ImplItemMacro {
1077 attrs: self.attrs.clone(),
1078 mac: self.mac.clone(),
1079 semi_token: self.semi_token.clone(),
1080 }
1081 }
1082}
1083#[cfg(feature = "full")]
1084#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1085impl Clone for crate::ImplItemType {
1086 fn clone(&self) -> Self {
1087 crate::ImplItemType {
1088 attrs: self.attrs.clone(),
1089 vis: self.vis.clone(),
1090 modifiers: self.modifiers.clone(),
1091 type_token: self.type_token.clone(),
1092 ident: self.ident.clone(),
1093 generics: self.generics.clone(),
1094 eq_token: self.eq_token.clone(),
1095 ty: self.ty.clone(),
1096 semi_token: self.semi_token.clone(),
1097 }
1098 }
1099}
1100#[cfg(feature = "full")]
1101#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1102impl Clone for crate::ImplModifiers {
1103 fn clone(&self) -> Self {
1104 crate::ImplModifiers {
1105 defaultness: self.defaultness.clone(),
1106 polarity: self.polarity.clone(),
1107 }
1108 }
1109}
1110#[cfg(any(feature = "derive", feature = "full"))]
1111#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1112impl Clone for crate::Index {
1113 fn clone(&self) -> Self {
1114 crate::Index {
1115 index: self.index.clone(),
1116 span: self.span.clone(),
1117 }
1118 }
1119}
1120#[cfg(feature = "full")]
1121#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1122impl Clone for crate::Item {
1123 fn clone(&self) -> Self {
1124 match self {
1125 crate::Item::Const(v0) => crate::Item::Const(v0.clone()),
1126 crate::Item::Enum(v0) => crate::Item::Enum(v0.clone()),
1127 crate::Item::ExternCrate(v0) => crate::Item::ExternCrate(v0.clone()),
1128 crate::Item::Fn(v0) => crate::Item::Fn(v0.clone()),
1129 crate::Item::ForeignMod(v0) => crate::Item::ForeignMod(v0.clone()),
1130 crate::Item::Impl(v0) => crate::Item::Impl(v0.clone()),
1131 crate::Item::Macro(v0) => crate::Item::Macro(v0.clone()),
1132 crate::Item::Mod(v0) => crate::Item::Mod(v0.clone()),
1133 crate::Item::Static(v0) => crate::Item::Static(v0.clone()),
1134 crate::Item::Struct(v0) => crate::Item::Struct(v0.clone()),
1135 crate::Item::Trait(v0) => crate::Item::Trait(v0.clone()),
1136 crate::Item::TraitAlias(v0) => crate::Item::TraitAlias(v0.clone()),
1137 crate::Item::Type(v0) => crate::Item::Type(v0.clone()),
1138 crate::Item::Union(v0) => crate::Item::Union(v0.clone()),
1139 crate::Item::Use(v0) => crate::Item::Use(v0.clone()),
1140 crate::Item::Verbatim(v0) => crate::Item::Verbatim(v0.clone()),
1141 }
1142 }
1143}
1144#[cfg(feature = "full")]
1145#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1146impl Clone for crate::ItemConst {
1147 fn clone(&self) -> Self {
1148 crate::ItemConst {
1149 attrs: self.attrs.clone(),
1150 vis: self.vis.clone(),
1151 modifiers: self.modifiers.clone(),
1152 const_token: self.const_token.clone(),
1153 ident: self.ident.clone(),
1154 generics: self.generics.clone(),
1155 colon_token: self.colon_token.clone(),
1156 ty: self.ty.clone(),
1157 eq_token: self.eq_token.clone(),
1158 expr: self.expr.clone(),
1159 semi_token: self.semi_token.clone(),
1160 }
1161 }
1162}
1163#[cfg(feature = "full")]
1164#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1165impl Clone for crate::ItemEnum {
1166 fn clone(&self) -> Self {
1167 crate::ItemEnum {
1168 attrs: self.attrs.clone(),
1169 vis: self.vis.clone(),
1170 enum_token: self.enum_token.clone(),
1171 ident: self.ident.clone(),
1172 generics: self.generics.clone(),
1173 brace_token: self.brace_token.clone(),
1174 variants: self.variants.clone(),
1175 }
1176 }
1177}
1178#[cfg(feature = "full")]
1179#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1180impl Clone for crate::ItemExternCrate {
1181 fn clone(&self) -> Self {
1182 crate::ItemExternCrate {
1183 attrs: self.attrs.clone(),
1184 vis: self.vis.clone(),
1185 extern_token: self.extern_token.clone(),
1186 crate_token: self.crate_token.clone(),
1187 ident: self.ident.clone(),
1188 rename: self.rename.clone(),
1189 semi_token: self.semi_token.clone(),
1190 }
1191 }
1192}
1193#[cfg(feature = "full")]
1194#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1195impl Clone for crate::ItemFn {
1196 fn clone(&self) -> Self {
1197 crate::ItemFn {
1198 attrs: self.attrs.clone(),
1199 vis: self.vis.clone(),
1200 modifiers: self.modifiers.clone(),
1201 sig: self.sig.clone(),
1202 block: self.block.clone(),
1203 }
1204 }
1205}
1206#[cfg(feature = "full")]
1207#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1208impl Clone for crate::ItemForeignMod {
1209 fn clone(&self) -> Self {
1210 crate::ItemForeignMod {
1211 attrs: self.attrs.clone(),
1212 unsafety: self.unsafety.clone(),
1213 abi: self.abi.clone(),
1214 brace_token: self.brace_token.clone(),
1215 items: self.items.clone(),
1216 }
1217 }
1218}
1219#[cfg(feature = "full")]
1220#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1221impl Clone for crate::ItemImpl {
1222 fn clone(&self) -> Self {
1223 crate::ItemImpl {
1224 attrs: self.attrs.clone(),
1225 modifiers: self.modifiers.clone(),
1226 unsafety: self.unsafety.clone(),
1227 impl_token: self.impl_token.clone(),
1228 generics: self.generics.clone(),
1229 trait_: self.trait_.clone(),
1230 self_ty: self.self_ty.clone(),
1231 brace_token: self.brace_token.clone(),
1232 items: self.items.clone(),
1233 }
1234 }
1235}
1236#[cfg(feature = "full")]
1237#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1238impl Clone for crate::ItemMacro {
1239 fn clone(&self) -> Self {
1240 crate::ItemMacro {
1241 attrs: self.attrs.clone(),
1242 ident: self.ident.clone(),
1243 mac: self.mac.clone(),
1244 semi_token: self.semi_token.clone(),
1245 }
1246 }
1247}
1248#[cfg(feature = "full")]
1249#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1250impl Clone for crate::ItemMod {
1251 fn clone(&self) -> Self {
1252 crate::ItemMod {
1253 attrs: self.attrs.clone(),
1254 vis: self.vis.clone(),
1255 unsafety: self.unsafety.clone(),
1256 mod_token: self.mod_token.clone(),
1257 ident: self.ident.clone(),
1258 content: self.content.clone(),
1259 semi: self.semi.clone(),
1260 }
1261 }
1262}
1263#[cfg(feature = "full")]
1264#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1265impl Clone for crate::ItemStatic {
1266 fn clone(&self) -> Self {
1267 crate::ItemStatic {
1268 attrs: self.attrs.clone(),
1269 vis: self.vis.clone(),
1270 static_token: self.static_token.clone(),
1271 mutability: self.mutability.clone(),
1272 ident: self.ident.clone(),
1273 colon_token: self.colon_token.clone(),
1274 ty: self.ty.clone(),
1275 eq_token: self.eq_token.clone(),
1276 expr: self.expr.clone(),
1277 semi_token: self.semi_token.clone(),
1278 }
1279 }
1280}
1281#[cfg(feature = "full")]
1282#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1283impl Clone for crate::ItemStruct {
1284 fn clone(&self) -> Self {
1285 crate::ItemStruct {
1286 attrs: self.attrs.clone(),
1287 vis: self.vis.clone(),
1288 struct_token: self.struct_token.clone(),
1289 ident: self.ident.clone(),
1290 generics: self.generics.clone(),
1291 fields: self.fields.clone(),
1292 semi_token: self.semi_token.clone(),
1293 }
1294 }
1295}
1296#[cfg(feature = "full")]
1297#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1298impl Clone for crate::ItemTrait {
1299 fn clone(&self) -> Self {
1300 crate::ItemTrait {
1301 attrs: self.attrs.clone(),
1302 vis: self.vis.clone(),
1303 modifiers: self.modifiers.clone(),
1304 unsafety: self.unsafety.clone(),
1305 trait_token: self.trait_token.clone(),
1306 ident: self.ident.clone(),
1307 generics: self.generics.clone(),
1308 colon_token: self.colon_token.clone(),
1309 supertraits: self.supertraits.clone(),
1310 brace_token: self.brace_token.clone(),
1311 items: self.items.clone(),
1312 }
1313 }
1314}
1315#[cfg(feature = "full")]
1316#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1317impl Clone for crate::ItemTraitAlias {
1318 fn clone(&self) -> Self {
1319 crate::ItemTraitAlias {
1320 attrs: self.attrs.clone(),
1321 vis: self.vis.clone(),
1322 trait_token: self.trait_token.clone(),
1323 ident: self.ident.clone(),
1324 generics: self.generics.clone(),
1325 eq_token: self.eq_token.clone(),
1326 bounds: self.bounds.clone(),
1327 semi_token: self.semi_token.clone(),
1328 }
1329 }
1330}
1331#[cfg(feature = "full")]
1332#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1333impl Clone for crate::ItemType {
1334 fn clone(&self) -> Self {
1335 crate::ItemType {
1336 attrs: self.attrs.clone(),
1337 vis: self.vis.clone(),
1338 modifiers: self.modifiers.clone(),
1339 type_token: self.type_token.clone(),
1340 ident: self.ident.clone(),
1341 generics: self.generics.clone(),
1342 eq_token: self.eq_token.clone(),
1343 ty: self.ty.clone(),
1344 semi_token: self.semi_token.clone(),
1345 where_clause_placement: self.where_clause_placement.clone(),
1346 }
1347 }
1348}
1349#[cfg(feature = "full")]
1350#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1351impl Clone for crate::ItemUnion {
1352 fn clone(&self) -> Self {
1353 crate::ItemUnion {
1354 attrs: self.attrs.clone(),
1355 vis: self.vis.clone(),
1356 union_token: self.union_token.clone(),
1357 ident: self.ident.clone(),
1358 generics: self.generics.clone(),
1359 fields: self.fields.clone(),
1360 }
1361 }
1362}
1363#[cfg(feature = "full")]
1364#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1365impl Clone for crate::ItemUse {
1366 fn clone(&self) -> Self {
1367 crate::ItemUse {
1368 attrs: self.attrs.clone(),
1369 vis: self.vis.clone(),
1370 use_token: self.use_token.clone(),
1371 leading_colon: self.leading_colon.clone(),
1372 tree: self.tree.clone(),
1373 semi_token: self.semi_token.clone(),
1374 }
1375 }
1376}
1377#[cfg(feature = "full")]
1378#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1379impl Clone for crate::Label {
1380 fn clone(&self) -> Self {
1381 crate::Label {
1382 name: self.name.clone(),
1383 colon_token: self.colon_token.clone(),
1384 }
1385 }
1386}
1387#[cfg(any(feature = "derive", feature = "full"))]
1388#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1389impl Clone for crate::LifetimeParam {
1390 fn clone(&self) -> Self {
1391 crate::LifetimeParam {
1392 attrs: self.attrs.clone(),
1393 lifetime: self.lifetime.clone(),
1394 colon_token: self.colon_token.clone(),
1395 bounds: self.bounds.clone(),
1396 }
1397 }
1398}
1399#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1400impl Clone for crate::Lit {
1401 fn clone(&self) -> Self {
1402 match self {
1403 crate::Lit::Str(v0) => crate::Lit::Str(v0.clone()),
1404 crate::Lit::ByteStr(v0) => crate::Lit::ByteStr(v0.clone()),
1405 crate::Lit::CStr(v0) => crate::Lit::CStr(v0.clone()),
1406 crate::Lit::Byte(v0) => crate::Lit::Byte(v0.clone()),
1407 crate::Lit::Char(v0) => crate::Lit::Char(v0.clone()),
1408 crate::Lit::Int(v0) => crate::Lit::Int(v0.clone()),
1409 crate::Lit::Float(v0) => crate::Lit::Float(v0.clone()),
1410 crate::Lit::Bool(v0) => crate::Lit::Bool(v0.clone()),
1411 crate::Lit::Verbatim(v0) => crate::Lit::Verbatim(v0.clone()),
1412 }
1413 }
1414}
1415#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1416impl Clone for crate::LitBool {
1417 fn clone(&self) -> Self {
1418 crate::LitBool {
1419 value: self.value.clone(),
1420 span: self.span.clone(),
1421 }
1422 }
1423}
1424#[cfg(feature = "full")]
1425#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1426impl Clone for crate::Local {
1427 fn clone(&self) -> Self {
1428 crate::Local {
1429 attrs: self.attrs.clone(),
1430 let_token: self.let_token.clone(),
1431 modifiers: self.modifiers.clone(),
1432 pat: self.pat.clone(),
1433 init: self.init.clone(),
1434 semi_token: self.semi_token.clone(),
1435 }
1436 }
1437}
1438#[cfg(feature = "full")]
1439#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1440impl Clone for crate::LocalInit {
1441 fn clone(&self) -> Self {
1442 crate::LocalInit {
1443 eq_token: self.eq_token.clone(),
1444 expr: self.expr.clone(),
1445 diverge: self.diverge.clone(),
1446 }
1447 }
1448}
1449#[cfg(feature = "full")]
1450#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1451impl Clone for crate::LocalModifiers {
1452 fn clone(&self) -> Self {
1453 crate::LocalModifiers {}
1454 }
1455}
1456#[cfg(any(feature = "derive", feature = "full"))]
1457#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1458impl Clone for crate::Macro {
1459 fn clone(&self) -> Self {
1460 crate::Macro {
1461 path: self.path.clone(),
1462 bang_token: self.bang_token.clone(),
1463 delimiter: self.delimiter.clone(),
1464 tokens: self.tokens.clone(),
1465 }
1466 }
1467}
1468#[cfg(any(feature = "derive", feature = "full"))]
1469#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1470impl Clone for crate::MacroDelimiter {
1471 fn clone(&self) -> Self {
1472 match self {
1473 crate::MacroDelimiter::Paren(v0) => crate::MacroDelimiter::Paren(v0.clone()),
1474 crate::MacroDelimiter::Brace(v0) => crate::MacroDelimiter::Brace(v0.clone()),
1475 crate::MacroDelimiter::Bracket(v0) => {
1476 crate::MacroDelimiter::Bracket(v0.clone())
1477 }
1478 }
1479 }
1480}
1481#[cfg(any(feature = "derive", feature = "full"))]
1482#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1483impl Clone for crate::Member {
1484 fn clone(&self) -> Self {
1485 match self {
1486 crate::Member::Named(v0) => crate::Member::Named(v0.clone()),
1487 crate::Member::Unnamed(v0) => crate::Member::Unnamed(v0.clone()),
1488 }
1489 }
1490}
1491#[cfg(any(feature = "derive", feature = "full"))]
1492#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1493impl Clone for crate::Meta {
1494 fn clone(&self) -> Self {
1495 match self {
1496 crate::Meta::Path(v0) => crate::Meta::Path(v0.clone()),
1497 crate::Meta::List(v0) => crate::Meta::List(v0.clone()),
1498 crate::Meta::NameValue(v0) => crate::Meta::NameValue(v0.clone()),
1499 }
1500 }
1501}
1502#[cfg(any(feature = "derive", feature = "full"))]
1503#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1504impl Clone for crate::MetaList {
1505 fn clone(&self) -> Self {
1506 crate::MetaList {
1507 path: self.path.clone(),
1508 delimiter: self.delimiter.clone(),
1509 tokens: self.tokens.clone(),
1510 }
1511 }
1512}
1513#[cfg(any(feature = "derive", feature = "full"))]
1514#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1515impl Clone for crate::MetaNameValue {
1516 fn clone(&self) -> Self {
1517 crate::MetaNameValue {
1518 path: self.path.clone(),
1519 eq_token: self.eq_token.clone(),
1520 value: self.value.clone(),
1521 }
1522 }
1523}
1524#[cfg(any(feature = "derive", feature = "full"))]
1525#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1526impl Clone for crate::NamedArg {
1527 fn clone(&self) -> Self {
1528 crate::NamedArg {
1529 attrs: self.attrs.clone(),
1530 name: self.name.clone(),
1531 ty: self.ty.clone(),
1532 }
1533 }
1534}
1535#[cfg(any(feature = "derive", feature = "full"))]
1536#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1537impl Clone for crate::ParenthesizedGenericArguments {
1538 fn clone(&self) -> Self {
1539 crate::ParenthesizedGenericArguments {
1540 paren_token: self.paren_token.clone(),
1541 inputs: self.inputs.clone(),
1542 output: self.output.clone(),
1543 }
1544 }
1545}
1546#[cfg(feature = "full")]
1547#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1548impl Clone for crate::Pat {
1549 fn clone(&self) -> Self {
1550 match self {
1551 crate::Pat::Const(v0) => crate::Pat::Const(v0.clone()),
1552 crate::Pat::Guard(v0) => crate::Pat::Guard(v0.clone()),
1553 crate::Pat::Ident(v0) => crate::Pat::Ident(v0.clone()),
1554 crate::Pat::Lit(v0) => crate::Pat::Lit(v0.clone()),
1555 crate::Pat::Macro(v0) => crate::Pat::Macro(v0.clone()),
1556 crate::Pat::Or(v0) => crate::Pat::Or(v0.clone()),
1557 crate::Pat::Paren(v0) => crate::Pat::Paren(v0.clone()),
1558 crate::Pat::Path(v0) => crate::Pat::Path(v0.clone()),
1559 crate::Pat::Range(v0) => crate::Pat::Range(v0.clone()),
1560 crate::Pat::Reference(v0) => crate::Pat::Reference(v0.clone()),
1561 crate::Pat::Rest(v0) => crate::Pat::Rest(v0.clone()),
1562 crate::Pat::Slice(v0) => crate::Pat::Slice(v0.clone()),
1563 crate::Pat::Struct(v0) => crate::Pat::Struct(v0.clone()),
1564 crate::Pat::Tuple(v0) => crate::Pat::Tuple(v0.clone()),
1565 crate::Pat::TupleStruct(v0) => crate::Pat::TupleStruct(v0.clone()),
1566 crate::Pat::Type(v0) => crate::Pat::Type(v0.clone()),
1567 crate::Pat::Verbatim(v0) => crate::Pat::Verbatim(v0.clone()),
1568 crate::Pat::Wild(v0) => crate::Pat::Wild(v0.clone()),
1569 }
1570 }
1571}
1572#[cfg(feature = "full")]
1573#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1574impl Clone for crate::PatGuard {
1575 fn clone(&self) -> Self {
1576 crate::PatGuard {
1577 attrs: self.attrs.clone(),
1578 pat: self.pat.clone(),
1579 if_token: self.if_token.clone(),
1580 guard: self.guard.clone(),
1581 }
1582 }
1583}
1584#[cfg(feature = "full")]
1585#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1586impl Clone for crate::PatIdent {
1587 fn clone(&self) -> Self {
1588 crate::PatIdent {
1589 attrs: self.attrs.clone(),
1590 by_ref: self.by_ref.clone(),
1591 mutability: self.mutability.clone(),
1592 ident: self.ident.clone(),
1593 subpat: self.subpat.clone(),
1594 }
1595 }
1596}
1597#[cfg(feature = "full")]
1598#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1599impl Clone for crate::PatOr {
1600 fn clone(&self) -> Self {
1601 crate::PatOr {
1602 attrs: self.attrs.clone(),
1603 leading_vert: self.leading_vert.clone(),
1604 cases: self.cases.clone(),
1605 }
1606 }
1607}
1608#[cfg(feature = "full")]
1609#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1610impl Clone for crate::PatParen {
1611 fn clone(&self) -> Self {
1612 crate::PatParen {
1613 attrs: self.attrs.clone(),
1614 paren_token: self.paren_token.clone(),
1615 pat: self.pat.clone(),
1616 }
1617 }
1618}
1619#[cfg(feature = "full")]
1620#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1621impl Clone for crate::PatReference {
1622 fn clone(&self) -> Self {
1623 crate::PatReference {
1624 attrs: self.attrs.clone(),
1625 and_token: self.and_token.clone(),
1626 mutability: self.mutability.clone(),
1627 pat: self.pat.clone(),
1628 }
1629 }
1630}
1631#[cfg(feature = "full")]
1632#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1633impl Clone for crate::PatRest {
1634 fn clone(&self) -> Self {
1635 crate::PatRest {
1636 attrs: self.attrs.clone(),
1637 dot2_token: self.dot2_token.clone(),
1638 }
1639 }
1640}
1641#[cfg(feature = "full")]
1642#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1643impl Clone for crate::PatSlice {
1644 fn clone(&self) -> Self {
1645 crate::PatSlice {
1646 attrs: self.attrs.clone(),
1647 bracket_token: self.bracket_token.clone(),
1648 elems: self.elems.clone(),
1649 }
1650 }
1651}
1652#[cfg(feature = "full")]
1653#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1654impl Clone for crate::PatStruct {
1655 fn clone(&self) -> Self {
1656 crate::PatStruct {
1657 attrs: self.attrs.clone(),
1658 qself: self.qself.clone(),
1659 path: self.path.clone(),
1660 brace_token: self.brace_token.clone(),
1661 fields: self.fields.clone(),
1662 rest: self.rest.clone(),
1663 }
1664 }
1665}
1666#[cfg(feature = "full")]
1667#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1668impl Clone for crate::PatTuple {
1669 fn clone(&self) -> Self {
1670 crate::PatTuple {
1671 attrs: self.attrs.clone(),
1672 paren_token: self.paren_token.clone(),
1673 elems: self.elems.clone(),
1674 }
1675 }
1676}
1677#[cfg(feature = "full")]
1678#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1679impl Clone for crate::PatTupleStruct {
1680 fn clone(&self) -> Self {
1681 crate::PatTupleStruct {
1682 attrs: self.attrs.clone(),
1683 qself: self.qself.clone(),
1684 path: self.path.clone(),
1685 paren_token: self.paren_token.clone(),
1686 elems: self.elems.clone(),
1687 }
1688 }
1689}
1690#[cfg(feature = "full")]
1691#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1692impl Clone for crate::PatType {
1693 fn clone(&self) -> Self {
1694 crate::PatType {
1695 attrs: self.attrs.clone(),
1696 pat: self.pat.clone(),
1697 colon_token: self.colon_token.clone(),
1698 ty: self.ty.clone(),
1699 }
1700 }
1701}
1702#[cfg(feature = "full")]
1703#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1704impl Clone for crate::PatWild {
1705 fn clone(&self) -> Self {
1706 crate::PatWild {
1707 attrs: self.attrs.clone(),
1708 underscore_token: self.underscore_token.clone(),
1709 }
1710 }
1711}
1712#[cfg(any(feature = "derive", feature = "full"))]
1713#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1714impl Clone for crate::Path {
1715 fn clone(&self) -> Self {
1716 crate::Path {
1717 leading_colon: self.leading_colon.clone(),
1718 segments: self.segments.clone(),
1719 }
1720 }
1721}
1722#[cfg(any(feature = "derive", feature = "full"))]
1723#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1724impl Clone for crate::PathArguments {
1725 fn clone(&self) -> Self {
1726 match self {
1727 crate::PathArguments::None => crate::PathArguments::None,
1728 crate::PathArguments::AngleBracketed(v0) => {
1729 crate::PathArguments::AngleBracketed(v0.clone())
1730 }
1731 crate::PathArguments::Parenthesized(v0) => {
1732 crate::PathArguments::Parenthesized(v0.clone())
1733 }
1734 }
1735 }
1736}
1737#[cfg(any(feature = "derive", feature = "full"))]
1738#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1739impl Clone for crate::PathSegment {
1740 fn clone(&self) -> Self {
1741 crate::PathSegment {
1742 ident: self.ident.clone(),
1743 arguments: self.arguments.clone(),
1744 }
1745 }
1746}
1747#[cfg(any(feature = "derive", feature = "full"))]
1748#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1749impl Clone for crate::PointerMutability {
1750 fn clone(&self) -> Self {
1751 match self {
1752 crate::PointerMutability::Const(v0) => {
1753 crate::PointerMutability::Const(v0.clone())
1754 }
1755 crate::PointerMutability::Mut(v0) => {
1756 crate::PointerMutability::Mut(v0.clone())
1757 }
1758 }
1759 }
1760}
1761#[cfg(feature = "full")]
1762#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1763impl Clone for crate::PreciseCapture {
1764 fn clone(&self) -> Self {
1765 crate::PreciseCapture {
1766 use_token: self.use_token.clone(),
1767 lt_token: self.lt_token.clone(),
1768 params: self.params.clone(),
1769 gt_token: self.gt_token.clone(),
1770 }
1771 }
1772}
1773#[cfg(any(feature = "derive", feature = "full"))]
1774#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1775impl Clone for crate::PredicateLifetime {
1776 fn clone(&self) -> Self {
1777 crate::PredicateLifetime {
1778 attrs: self.attrs.clone(),
1779 lifetime: self.lifetime.clone(),
1780 colon_token: self.colon_token.clone(),
1781 bounds: self.bounds.clone(),
1782 }
1783 }
1784}
1785#[cfg(any(feature = "derive", feature = "full"))]
1786#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1787impl Clone for crate::PredicateType {
1788 fn clone(&self) -> Self {
1789 crate::PredicateType {
1790 attrs: self.attrs.clone(),
1791 lifetimes: self.lifetimes.clone(),
1792 bounded_ty: self.bounded_ty.clone(),
1793 colon_token: self.colon_token.clone(),
1794 bounds: self.bounds.clone(),
1795 }
1796 }
1797}
1798#[cfg(any(feature = "derive", feature = "full"))]
1799#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1800impl Clone for crate::QSelf {
1801 fn clone(&self) -> Self {
1802 crate::QSelf {
1803 lt_token: self.lt_token.clone(),
1804 ty: self.ty.clone(),
1805 position: self.position.clone(),
1806 as_token: self.as_token.clone(),
1807 gt_token: self.gt_token.clone(),
1808 }
1809 }
1810}
1811#[cfg(feature = "full")]
1812#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1813impl Copy for crate::RangeLimits {}
1814#[cfg(feature = "full")]
1815#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1816impl Clone for crate::RangeLimits {
1817 fn clone(&self) -> Self {
1818 *self
1819 }
1820}
1821#[cfg(feature = "full")]
1822#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1823impl Clone for crate::Receiver {
1824 fn clone(&self) -> Self {
1825 crate::Receiver {
1826 attrs: self.attrs.clone(),
1827 mutability: self.mutability.clone(),
1828 self_token: self.self_token.clone(),
1829 kind: self.kind.clone(),
1830 }
1831 }
1832}
1833#[cfg(feature = "full")]
1834#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1835impl Clone for crate::ReceiverKind {
1836 fn clone(&self) -> Self {
1837 match self {
1838 crate::ReceiverKind::Value => crate::ReceiverKind::Value,
1839 crate::ReceiverKind::Reference(v0, v1, v2) => {
1840 crate::ReceiverKind::Reference(v0.clone(), v1.clone(), v2.clone())
1841 }
1842 crate::ReceiverKind::Typed(v0, v1) => {
1843 crate::ReceiverKind::Typed(v0.clone(), v1.clone())
1844 }
1845 }
1846 }
1847}
1848#[cfg(any(feature = "derive", feature = "full"))]
1849#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1850impl Clone for crate::ReturnType {
1851 fn clone(&self) -> Self {
1852 match self {
1853 crate::ReturnType::Default => crate::ReturnType::Default,
1854 crate::ReturnType::Type(v0, v1) => {
1855 crate::ReturnType::Type(v0.clone(), v1.clone())
1856 }
1857 }
1858 }
1859}
1860#[cfg(feature = "full")]
1861#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1862impl Clone for crate::Safety {
1863 fn clone(&self) -> Self {
1864 match self {
1865 crate::Safety::Safe(v0) => crate::Safety::Safe(v0.clone()),
1866 crate::Safety::Unsafe(v0) => crate::Safety::Unsafe(v0.clone()),
1867 crate::Safety::Default => crate::Safety::Default,
1868 }
1869 }
1870}
1871#[cfg(feature = "full")]
1872#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1873impl Clone for crate::Signature {
1874 fn clone(&self) -> Self {
1875 crate::Signature {
1876 constness: self.constness.clone(),
1877 asyncness: self.asyncness.clone(),
1878 safety: self.safety.clone(),
1879 abi: self.abi.clone(),
1880 fn_token: self.fn_token.clone(),
1881 ident: self.ident.clone(),
1882 generics: self.generics.clone(),
1883 paren_token: self.paren_token.clone(),
1884 inputs: self.inputs.clone(),
1885 variadic: self.variadic.clone(),
1886 output: self.output.clone(),
1887 }
1888 }
1889}
1890#[cfg(feature = "full")]
1891#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1892impl Clone for crate::StaticMutability {
1893 fn clone(&self) -> Self {
1894 match self {
1895 crate::StaticMutability::Mut(v0) => crate::StaticMutability::Mut(v0.clone()),
1896 crate::StaticMutability::None => crate::StaticMutability::None,
1897 }
1898 }
1899}
1900#[cfg(feature = "full")]
1901#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1902impl Clone for crate::Stmt {
1903 fn clone(&self) -> Self {
1904 match self {
1905 crate::Stmt::Local(v0) => crate::Stmt::Local(v0.clone()),
1906 crate::Stmt::Item(v0) => crate::Stmt::Item(v0.clone()),
1907 crate::Stmt::Expr(v0, v1) => crate::Stmt::Expr(v0.clone(), v1.clone()),
1908 crate::Stmt::Macro(v0) => crate::Stmt::Macro(v0.clone()),
1909 }
1910 }
1911}
1912#[cfg(feature = "full")]
1913#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1914impl Clone for crate::StmtMacro {
1915 fn clone(&self) -> Self {
1916 crate::StmtMacro {
1917 attrs: self.attrs.clone(),
1918 mac: self.mac.clone(),
1919 semi_token: self.semi_token.clone(),
1920 }
1921 }
1922}
1923#[cfg(any(feature = "derive", feature = "full"))]
1924#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1925impl Clone for crate::TraitBound {
1926 fn clone(&self) -> Self {
1927 crate::TraitBound {
1928 paren_token: self.paren_token.clone(),
1929 lifetimes: self.lifetimes.clone(),
1930 modifiers: self.modifiers.clone(),
1931 maybe: self.maybe.clone(),
1932 path: self.path.clone(),
1933 }
1934 }
1935}
1936#[cfg(any(feature = "derive", feature = "full"))]
1937#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1938impl Clone for crate::TraitBoundModifiers {
1939 fn clone(&self) -> Self {
1940 crate::TraitBoundModifiers {}
1941 }
1942}
1943#[cfg(feature = "full")]
1944#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1945impl Clone for crate::TraitItem {
1946 fn clone(&self) -> Self {
1947 match self {
1948 crate::TraitItem::Const(v0) => crate::TraitItem::Const(v0.clone()),
1949 crate::TraitItem::Fn(v0) => crate::TraitItem::Fn(v0.clone()),
1950 crate::TraitItem::Type(v0) => crate::TraitItem::Type(v0.clone()),
1951 crate::TraitItem::Macro(v0) => crate::TraitItem::Macro(v0.clone()),
1952 crate::TraitItem::Verbatim(v0) => crate::TraitItem::Verbatim(v0.clone()),
1953 }
1954 }
1955}
1956#[cfg(feature = "full")]
1957#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1958impl Clone for crate::TraitItemConst {
1959 fn clone(&self) -> Self {
1960 crate::TraitItemConst {
1961 attrs: self.attrs.clone(),
1962 modifiers: self.modifiers.clone(),
1963 const_token: self.const_token.clone(),
1964 ident: self.ident.clone(),
1965 generics: self.generics.clone(),
1966 colon_token: self.colon_token.clone(),
1967 ty: self.ty.clone(),
1968 default: self.default.clone(),
1969 semi_token: self.semi_token.clone(),
1970 }
1971 }
1972}
1973#[cfg(feature = "full")]
1974#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1975impl Clone for crate::TraitItemFn {
1976 fn clone(&self) -> Self {
1977 crate::TraitItemFn {
1978 attrs: self.attrs.clone(),
1979 modifiers: self.modifiers.clone(),
1980 sig: self.sig.clone(),
1981 default: self.default.clone(),
1982 semi_token: self.semi_token.clone(),
1983 }
1984 }
1985}
1986#[cfg(feature = "full")]
1987#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1988impl Clone for crate::TraitItemMacro {
1989 fn clone(&self) -> Self {
1990 crate::TraitItemMacro {
1991 attrs: self.attrs.clone(),
1992 mac: self.mac.clone(),
1993 semi_token: self.semi_token.clone(),
1994 }
1995 }
1996}
1997#[cfg(feature = "full")]
1998#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1999impl Clone for crate::TraitItemType {
2000 fn clone(&self) -> Self {
2001 crate::TraitItemType {
2002 attrs: self.attrs.clone(),
2003 modifiers: self.modifiers.clone(),
2004 type_token: self.type_token.clone(),
2005 ident: self.ident.clone(),
2006 generics: self.generics.clone(),
2007 colon_token: self.colon_token.clone(),
2008 bounds: self.bounds.clone(),
2009 default: self.default.clone(),
2010 semi_token: self.semi_token.clone(),
2011 }
2012 }
2013}
2014#[cfg(feature = "full")]
2015#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2016impl Clone for crate::TraitModifiers {
2017 fn clone(&self) -> Self {
2018 crate::TraitModifiers {
2019 auto_token: self.auto_token.clone(),
2020 }
2021 }
2022}
2023#[cfg(any(feature = "derive", feature = "full"))]
2024#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2025impl Clone for crate::Type {
2026 fn clone(&self) -> Self {
2027 match self {
2028 crate::Type::Array(v0) => crate::Type::Array(v0.clone()),
2029 crate::Type::FnPtr(v0) => crate::Type::FnPtr(v0.clone()),
2030 crate::Type::Group(v0) => crate::Type::Group(v0.clone()),
2031 crate::Type::ImplTrait(v0) => crate::Type::ImplTrait(v0.clone()),
2032 crate::Type::Infer(v0) => crate::Type::Infer(v0.clone()),
2033 crate::Type::Macro(v0) => crate::Type::Macro(v0.clone()),
2034 crate::Type::Never(v0) => crate::Type::Never(v0.clone()),
2035 crate::Type::Paren(v0) => crate::Type::Paren(v0.clone()),
2036 crate::Type::Path(v0) => crate::Type::Path(v0.clone()),
2037 crate::Type::Ptr(v0) => crate::Type::Ptr(v0.clone()),
2038 crate::Type::Reference(v0) => crate::Type::Reference(v0.clone()),
2039 crate::Type::Slice(v0) => crate::Type::Slice(v0.clone()),
2040 crate::Type::TraitObject(v0) => crate::Type::TraitObject(v0.clone()),
2041 crate::Type::Tuple(v0) => crate::Type::Tuple(v0.clone()),
2042 crate::Type::Verbatim(v0) => crate::Type::Verbatim(v0.clone()),
2043 }
2044 }
2045}
2046#[cfg(any(feature = "derive", feature = "full"))]
2047#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2048impl Clone for crate::TypeArray {
2049 fn clone(&self) -> Self {
2050 crate::TypeArray {
2051 attrs: self.attrs.clone(),
2052 bracket_token: self.bracket_token.clone(),
2053 elem: self.elem.clone(),
2054 semi_token: self.semi_token.clone(),
2055 len: self.len.clone(),
2056 }
2057 }
2058}
2059#[cfg(any(feature = "derive", feature = "full"))]
2060#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2061impl Clone for crate::TypeFnPtr {
2062 fn clone(&self) -> Self {
2063 crate::TypeFnPtr {
2064 attrs: self.attrs.clone(),
2065 lifetimes: self.lifetimes.clone(),
2066 unsafety: self.unsafety.clone(),
2067 abi: self.abi.clone(),
2068 fn_token: self.fn_token.clone(),
2069 paren_token: self.paren_token.clone(),
2070 inputs: self.inputs.clone(),
2071 variadic: self.variadic.clone(),
2072 output: self.output.clone(),
2073 }
2074 }
2075}
2076#[cfg(any(feature = "derive", feature = "full"))]
2077#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2078impl Clone for crate::TypeGroup {
2079 fn clone(&self) -> Self {
2080 crate::TypeGroup {
2081 attrs: self.attrs.clone(),
2082 group_token: self.group_token.clone(),
2083 elem: self.elem.clone(),
2084 }
2085 }
2086}
2087#[cfg(any(feature = "derive", feature = "full"))]
2088#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2089impl Clone for crate::TypeImplTrait {
2090 fn clone(&self) -> Self {
2091 crate::TypeImplTrait {
2092 attrs: self.attrs.clone(),
2093 impl_token: self.impl_token.clone(),
2094 bounds: self.bounds.clone(),
2095 }
2096 }
2097}
2098#[cfg(any(feature = "derive", feature = "full"))]
2099#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2100impl Clone for crate::TypeInfer {
2101 fn clone(&self) -> Self {
2102 crate::TypeInfer {
2103 attrs: self.attrs.clone(),
2104 underscore_token: self.underscore_token.clone(),
2105 }
2106 }
2107}
2108#[cfg(any(feature = "derive", feature = "full"))]
2109#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2110impl Clone for crate::TypeMacro {
2111 fn clone(&self) -> Self {
2112 crate::TypeMacro {
2113 attrs: self.attrs.clone(),
2114 mac: self.mac.clone(),
2115 }
2116 }
2117}
2118#[cfg(feature = "full")]
2119#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2120impl Clone for crate::TypeModifiers {
2121 fn clone(&self) -> Self {
2122 crate::TypeModifiers {
2123 defaultness: self.defaultness.clone(),
2124 }
2125 }
2126}
2127#[cfg(any(feature = "derive", feature = "full"))]
2128#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2129impl Clone for crate::TypeNever {
2130 fn clone(&self) -> Self {
2131 crate::TypeNever {
2132 attrs: self.attrs.clone(),
2133 bang_token: self.bang_token.clone(),
2134 }
2135 }
2136}
2137#[cfg(any(feature = "derive", feature = "full"))]
2138#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2139impl Clone for crate::TypeParam {
2140 fn clone(&self) -> Self {
2141 crate::TypeParam {
2142 attrs: self.attrs.clone(),
2143 ident: self.ident.clone(),
2144 colon_token: self.colon_token.clone(),
2145 bounds: self.bounds.clone(),
2146 default: self.default.clone(),
2147 }
2148 }
2149}
2150#[cfg(any(feature = "derive", feature = "full"))]
2151#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2152impl Clone for crate::TypeParamBound {
2153 fn clone(&self) -> Self {
2154 match self {
2155 crate::TypeParamBound::Trait(v0) => crate::TypeParamBound::Trait(v0.clone()),
2156 crate::TypeParamBound::Lifetime(v0) => {
2157 crate::TypeParamBound::Lifetime(v0.clone())
2158 }
2159 #[cfg(feature = "full")]
2160 crate::TypeParamBound::PreciseCapture(v0) => {
2161 crate::TypeParamBound::PreciseCapture(v0.clone())
2162 }
2163 crate::TypeParamBound::Verbatim(v0) => {
2164 crate::TypeParamBound::Verbatim(v0.clone())
2165 }
2166 #[cfg(not(feature = "full"))]
2167 _ => unreachable!(),
2168 }
2169 }
2170}
2171#[cfg(any(feature = "derive", feature = "full"))]
2172#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2173impl Clone for crate::TypeParen {
2174 fn clone(&self) -> Self {
2175 crate::TypeParen {
2176 attrs: self.attrs.clone(),
2177 paren_token: self.paren_token.clone(),
2178 elem: self.elem.clone(),
2179 }
2180 }
2181}
2182#[cfg(any(feature = "derive", feature = "full"))]
2183#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2184impl Clone for crate::TypePath {
2185 fn clone(&self) -> Self {
2186 crate::TypePath {
2187 attrs: self.attrs.clone(),
2188 qself: self.qself.clone(),
2189 path: self.path.clone(),
2190 }
2191 }
2192}
2193#[cfg(any(feature = "derive", feature = "full"))]
2194#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2195impl Clone for crate::TypePtr {
2196 fn clone(&self) -> Self {
2197 crate::TypePtr {
2198 attrs: self.attrs.clone(),
2199 star_token: self.star_token.clone(),
2200 mutability: self.mutability.clone(),
2201 elem: self.elem.clone(),
2202 }
2203 }
2204}
2205#[cfg(any(feature = "derive", feature = "full"))]
2206#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2207impl Clone for crate::TypeReference {
2208 fn clone(&self) -> Self {
2209 crate::TypeReference {
2210 attrs: self.attrs.clone(),
2211 and_token: self.and_token.clone(),
2212 lifetime: self.lifetime.clone(),
2213 mutability: self.mutability.clone(),
2214 elem: self.elem.clone(),
2215 }
2216 }
2217}
2218#[cfg(any(feature = "derive", feature = "full"))]
2219#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2220impl Clone for crate::TypeSlice {
2221 fn clone(&self) -> Self {
2222 crate::TypeSlice {
2223 attrs: self.attrs.clone(),
2224 bracket_token: self.bracket_token.clone(),
2225 elem: self.elem.clone(),
2226 }
2227 }
2228}
2229#[cfg(any(feature = "derive", feature = "full"))]
2230#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2231impl Clone for crate::TypeTraitObject {
2232 fn clone(&self) -> Self {
2233 crate::TypeTraitObject {
2234 attrs: self.attrs.clone(),
2235 dyn_token: self.dyn_token.clone(),
2236 bounds: self.bounds.clone(),
2237 }
2238 }
2239}
2240#[cfg(any(feature = "derive", feature = "full"))]
2241#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2242impl Clone for crate::TypeTuple {
2243 fn clone(&self) -> Self {
2244 crate::TypeTuple {
2245 attrs: self.attrs.clone(),
2246 paren_token: self.paren_token.clone(),
2247 elems: self.elems.clone(),
2248 }
2249 }
2250}
2251#[cfg(any(feature = "derive", feature = "full"))]
2252#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2253impl Copy for crate::UnOp {}
2254#[cfg(any(feature = "derive", feature = "full"))]
2255#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2256impl Clone for crate::UnOp {
2257 fn clone(&self) -> Self {
2258 *self
2259 }
2260}
2261#[cfg(feature = "full")]
2262#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2263impl Clone for crate::UseGlob {
2264 fn clone(&self) -> Self {
2265 crate::UseGlob {
2266 star_token: self.star_token.clone(),
2267 }
2268 }
2269}
2270#[cfg(feature = "full")]
2271#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2272impl Clone for crate::UseGroup {
2273 fn clone(&self) -> Self {
2274 crate::UseGroup {
2275 brace_token: self.brace_token.clone(),
2276 items: self.items.clone(),
2277 }
2278 }
2279}
2280#[cfg(feature = "full")]
2281#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2282impl Clone for crate::UseName {
2283 fn clone(&self) -> Self {
2284 crate::UseName {
2285 ident: self.ident.clone(),
2286 }
2287 }
2288}
2289#[cfg(feature = "full")]
2290#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2291impl Clone for crate::UsePath {
2292 fn clone(&self) -> Self {
2293 crate::UsePath {
2294 ident: self.ident.clone(),
2295 colon2_token: self.colon2_token.clone(),
2296 tree: self.tree.clone(),
2297 }
2298 }
2299}
2300#[cfg(feature = "full")]
2301#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2302impl Clone for crate::UseRename {
2303 fn clone(&self) -> Self {
2304 crate::UseRename {
2305 ident: self.ident.clone(),
2306 as_token: self.as_token.clone(),
2307 rename: self.rename.clone(),
2308 }
2309 }
2310}
2311#[cfg(feature = "full")]
2312#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2313impl Clone for crate::UseTree {
2314 fn clone(&self) -> Self {
2315 match self {
2316 crate::UseTree::Path(v0) => crate::UseTree::Path(v0.clone()),
2317 crate::UseTree::Name(v0) => crate::UseTree::Name(v0.clone()),
2318 crate::UseTree::Rename(v0) => crate::UseTree::Rename(v0.clone()),
2319 crate::UseTree::Glob(v0) => crate::UseTree::Glob(v0.clone()),
2320 crate::UseTree::Group(v0) => crate::UseTree::Group(v0.clone()),
2321 }
2322 }
2323}
2324#[cfg(feature = "full")]
2325#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2326impl Clone for crate::Variadic {
2327 fn clone(&self) -> Self {
2328 crate::Variadic {
2329 attrs: self.attrs.clone(),
2330 pat: self.pat.clone(),
2331 dots: self.dots.clone(),
2332 comma: self.comma.clone(),
2333 }
2334 }
2335}
2336#[cfg(any(feature = "derive", feature = "full"))]
2337#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2338impl Clone for crate::Variant {
2339 fn clone(&self) -> Self {
2340 crate::Variant {
2341 attrs: self.attrs.clone(),
2342 ident: self.ident.clone(),
2343 fields: self.fields.clone(),
2344 discriminant: self.discriminant.clone(),
2345 }
2346 }
2347}
2348#[cfg(any(feature = "derive", feature = "full"))]
2349#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2350impl Clone for crate::VisRestricted {
2351 fn clone(&self) -> Self {
2352 crate::VisRestricted {
2353 pub_token: self.pub_token.clone(),
2354 paren_token: self.paren_token.clone(),
2355 in_token: self.in_token.clone(),
2356 path: self.path.clone(),
2357 }
2358 }
2359}
2360#[cfg(any(feature = "derive", feature = "full"))]
2361#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2362impl Clone for crate::Visibility {
2363 fn clone(&self) -> Self {
2364 match self {
2365 crate::Visibility::Public(v0) => crate::Visibility::Public(v0.clone()),
2366 crate::Visibility::Restricted(v0) => {
2367 crate::Visibility::Restricted(v0.clone())
2368 }
2369 crate::Visibility::Inherited => crate::Visibility::Inherited,
2370 }
2371 }
2372}
2373#[cfg(any(feature = "derive", feature = "full"))]
2374#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2375impl Clone for crate::WhereClause {
2376 fn clone(&self) -> Self {
2377 crate::WhereClause {
2378 where_token: self.where_token.clone(),
2379 predicates: self.predicates.clone(),
2380 }
2381 }
2382}
2383#[cfg(any(feature = "derive", feature = "full"))]
2384#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2385impl Clone for crate::WherePredicate {
2386 fn clone(&self) -> Self {
2387 match self {
2388 crate::WherePredicate::Lifetime(v0) => {
2389 crate::WherePredicate::Lifetime(v0.clone())
2390 }
2391 crate::WherePredicate::Type(v0) => crate::WherePredicate::Type(v0.clone()),
2392 }
2393 }
2394}