Function derive

crates/csskit_derives/src/semantic_eq.rs:18–101

(input: DeriveInput)

}

pub fn derive(input: DeriveInput) -> Result<TokenStream> {
	if let Data::Struct(ref s) = input.data
		&& matches!(s.fields, Fields::Unit)
	{
		return Err(Error::new(input.ident.span(), "Cannot derive SemanticEq on this struct"));
	}
	if matches!(input.data, Data::Union(_)) {
		return Err(Error::new(input.ident.span(), "Cannot derive SemanticEq on a Union"));
	}

	let s_a = structure_with_prefix(&input, "a")?;
	let s_b = structure_with_prefix(&input, "b")?;

	let mut wc = WhereCollector::new();
	for variant in s_a.variants() {
		for bi in variant.bindings() {
			wc.add(&bi.ast().ty);
		}
	}

	let ident = &input.ident;
	let (impl_generics, type_generics, _) = input.generics.split_for_impl();

	let body = if matches!(input.data, Data::Struct(_)) {
		let steps: Vec<TokenStream> = s_a.variants()[0]
			.bindings()
			.iter()
			.zip(s_b.variants()[0].bindings().iter())
			.map(|(a, b)| {
				let a_name = &a.binding;
				let b_name = &b.binding;
				quote! { #a_name.semantic_eq(&#b_name) }
			})
			.collect();
		let a_pat = s_a.variants()[0].pat();
		let b_pat = s_b.variants()[0].pat();
		let body = steps.into_iter().reduce(|acc, item| quote! { #acc && #item }).unwrap_or_default();
		quote! {
			let #a_pat = self;
			let #b_pat = other;
			#body
		}
	} else {
		let arms: TokenStream = s_a
			.variants()
			.iter()
			.zip(s_b.variants().iter())
			.map(|(va, vb)| {
				let a_pat = va.pat();
				let b_pat = vb.pat();
				let steps: Vec<TokenStream> = va
					.bindings()
					.iter()
					.zip(vb.bindings().iter())
					.map(|(a, b)| {
						let a_name = &a.binding;
						let b_name = &b.binding;
						quote! { #a_name.semantic_eq(&#b_name) }