Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
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")))]
9impl 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")))]
19impl 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")))]
31impl 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")))]
45impl 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")))]
57impl 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")))]
69impl Copy for crate::AttrStyle {}
70#[cfg(any(feature = "derive", feature = "full"))]
71#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
72impl 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")))]
79impl 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")))]
91impl 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")))]
102impl 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")))]
114impl Copy for crate::BinOp {}
115#[cfg(any(feature = "derive", feature = "full"))]
116#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
117impl 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")))]
124impl 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")))]
134impl 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")))]
146impl 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")))]
158impl 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")))]
173impl 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")))]
185impl 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")))]
196impl 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")))]
207impl 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")))]
218impl 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")))]
228impl 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")))]
241impl 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")))]
315impl 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")))]
326impl 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")))]
338impl 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")))]
350impl 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")))]
362impl 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")))]
374impl 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")))]
385impl 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")))]
397impl 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")))]
409impl 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")))]
421impl 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")))]
440impl 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")))]
451impl 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")))]
462impl 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")))]
474impl 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")))]
489impl 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")))]
500impl 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")))]
513impl 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")))]
525impl 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")))]
535impl 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")))]
548impl 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")))]
558impl 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")))]
570impl 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")))]
580impl 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")))]
593impl 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")))]
608impl 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")))]
619impl 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")))]
630impl 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")))]
642impl 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")))]
655impl 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")))]
667impl 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")))]
680impl 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")))]
691impl 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")))]
706impl 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")))]
717impl 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")))]
728impl 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")))]
739impl 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")))]
750impl 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")))]
761impl 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")))]
774impl 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")))]
785impl 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")))]
799impl 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")))]
808impl 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")))]
820impl 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")))]
832impl 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")))]
843impl 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")))]
853impl 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")))]
863impl 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")))]
874impl 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")))]
884impl 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")))]
897impl 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")))]
909impl 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")))]
920impl 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")))]
936impl 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")))]
950impl 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")))]
974impl 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")))]
987impl 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")))]
999impl 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")))]
1012impl 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")))]
1031impl 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")))]
1044impl 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")))]
1055impl 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")))]
1072impl 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")))]
1079impl 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")))]
1089impl 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")))]
1113impl 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")))]
1131impl 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")))]
1146impl 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")))]
1161impl 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")))]
1173impl 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")))]
1186impl 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")))]
1203impl 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")))]
1215impl 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")))]
1230impl 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")))]
1248impl 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")))]
1263impl 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")))]
1283impl 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")))]
1299impl 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")))]
1315impl 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")))]
1329impl 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")))]
1343impl 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")))]
1353impl 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")))]
1364impl 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")))]
1380impl 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")))]
1390impl 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")))]
1403impl 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")))]
1414impl 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")))]
1426impl 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")))]
1439impl 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")))]
1449impl 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")))]
1460impl 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")))]
1471impl 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")))]
1482impl 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")))]
1493impl 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")))]
1518impl 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")))]
1531impl 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")))]
1542impl 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")))]
1553impl 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")))]
1565impl 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")))]
1575impl 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")))]
1586impl 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")))]
1600impl 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")))]
1611impl 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")))]
1624impl 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")))]
1636impl 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")))]
1646impl 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")))]
1656impl 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")))]
1671impl 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")))]
1681impl 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")))]
1695impl 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")))]
1707impl 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")))]
1718impl 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")))]
1730impl 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")))]
1743impl Copy for crate::RangeLimits {}
1744#[cfg(feature = "full")]
1745#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1746impl 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")))]
1753impl 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")))]
1767impl 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")))]
1779impl 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")))]
1798impl 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")))]
1808impl 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")))]
1820impl 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")))]
1831impl 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")))]
1843impl Copy for crate::TraitBoundModifier {}
1844#[cfg(any(feature = "derive", feature = "full"))]
1845#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
1846impl 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")))]
1853impl 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")))]
1866impl 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")))]
1882impl 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")))]
1894impl 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")))]
1905impl 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")))]
1921impl 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")))]
1944impl 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")))]
1956impl 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")))]
1972impl 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")))]
1982impl 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")))]
1992impl 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")))]
2001impl 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")))]
2010impl 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")))]
2019impl 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")))]
2033impl 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")))]
2054impl 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")))]
2064impl 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")))]
2074impl 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")))]
2086impl 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")))]
2098impl 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")))]
2108impl 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")))]
2118impl 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")))]
2128impl Copy for crate::UnOp {}
2129#[cfg(any(feature = "derive", feature = "full"))]
2130#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
2131impl 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")))]
2138impl 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")))]
2147impl 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")))]
2157impl 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")))]
2166impl 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")))]
2177impl 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")))]
2188impl 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")))]
2201impl 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")))]
2213impl 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")))]
2225impl 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")))]
2237impl 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")))]
2250impl 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")))]
2260impl 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}