1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

//! [`Clone`](std::clone::Clone) implementation.

use proc_macro2::TokenStream;
use quote::quote;
use syn::{TraitBound, TraitBoundModifier, TypeParamBound};

use crate::{Data, DataType, DeriveTrait, Item, SimpleType, Trait, TraitImpl};

/// Dummy-struct implement [`Trait`] for [`Clone`](std::clone::Clone).
pub struct Clone;

impl TraitImpl for Clone {
	fn as_str(&self) -> &'static str {
		"Clone"
	}

	fn default_derive_trait(&self) -> DeriveTrait {
		DeriveTrait::Clone
	}

	fn supports_union(&self) -> bool {
		true
	}

	fn additional_where_bounds(&self, data: &Item) -> Option<TypeParamBound> {
		// `Clone` for unions requires the `Copy` bound.
		if let Item::Item(Data {
			type_: DataType::Union(..),
			..
		}) = data
		{
			Some(TypeParamBound::Trait(TraitBound {
				paren_token: None,
				modifier: TraitBoundModifier::None,
				lifetimes: None,
				path: Trait::Copy.default_derive_trait().path(),
			}))
		} else {
			None
		}
	}

	fn build_signature(
		&self,
		item: &Item,
		traits: &[DeriveTrait],
		_trait_: &DeriveTrait,
		body: &TokenStream,
	) -> TokenStream {
		// Special implementation for items also implementing `Copy`.
		if traits.iter().any(|trait_| trait_ == Trait::Copy) {
			return quote! {
				#[inline]
				fn clone(&self) -> Self { *self }
			};
		}

		// Special implementation for unions.
		if let Item::Item(Data {
			type_: DataType::Union(..),
			..
		}) = item
		{
			quote! {
				#[inline]
				fn clone(&self) -> Self {
					struct __AssertCopy<__T: ::core::marker::Copy + ?::core::marker::Sized>(::core::marker::PhantomData<__T>);
					let _: __AssertCopy<Self>;
					*self
				}
			}
		} else {
			quote! {
				#[inline]
				fn clone(&self) -> Self {
					match self {
						#body
					}
				}
			}
		}
	}

	fn build_body(&self, traits: &[DeriveTrait], trait_: &DeriveTrait, data: &Data) -> TokenStream {
		if traits.iter().any(|trait_| trait_ == Trait::Copy) {
			return TokenStream::new();
		}

		match data.simple_type() {
			SimpleType::Struct(fields) => {
				let self_pattern = &fields.self_pattern;
				let item_path = &data.path;
				let self_ident = data.iter_self_ident(**trait_);
				let fields = data.iter_field_ident(**trait_);
				let trait_path = trait_.path();

				quote! {
					#self_pattern => #item_path { #(#fields: #trait_path::clone(#self_ident)),* },
				}
			}
			SimpleType::Tuple(fields) => {
				let self_pattern = &fields.self_pattern;
				let item_path = &data.path;
				let self_ident = data.iter_self_ident(**trait_);
				let trait_path = trait_.path();

				quote! {
					#self_pattern => #item_path(#(#trait_path::clone(#self_ident)),*),
				}
			}
			SimpleType::Unit(pattern) => {
				quote! { #pattern => #pattern, }
			}
			SimpleType::Union(_) => TokenStream::new(),
		}
	}
}