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
118
119
120
121
122
123
124
125

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */

use crate::animate::{AnimationFieldAttrs, AnimationInputAttrs, AnimationVariantAttrs};
use crate::cg;
use proc_macro2::TokenStream;
use quote::TokenStreamExt;
use syn::{DeriveInput, WhereClause};
use synstructure;

pub fn derive(mut input: DeriveInput) -> TokenStream {
    let animation_input_attrs = cg::parse_input_attrs::<AnimationInputAttrs>(&input);
    let no_bound = animation_input_attrs.no_bound.unwrap_or_default();
    let mut where_clause = input.generics.where_clause.take();
    for param in input.generics.type_params() {
        if !no_bound.iter().any(|name| name.is_ident(&param.ident)) {
            cg::add_predicate(
                &mut where_clause,
                parse_quote!(#param: crate::values::distance::ComputeSquaredDistance),
            );
        }
    }

    let (mut match_body, needs_catchall_branch) = {
        let s = synstructure::Structure::new(&input);
        let needs_catchall_branch = s.variants().len() > 1;

        let match_body = s.variants().iter().fold(quote!(), |body, variant| {
            let arm = derive_variant_arm(variant, &mut where_clause);
            quote! { #body #arm }
        });

        (match_body, needs_catchall_branch)
    };

    input.generics.where_clause = where_clause;

    if needs_catchall_branch {
        // This ideally shouldn't be needed, but see:
        // https://github.com/rust-lang/rust/issues/68867
        match_body.append_all(quote! { _ => unsafe { debug_unreachable!() } });
    }

    let name = &input.ident;
    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();

    quote! {
        impl #impl_generics crate::values::distance::ComputeSquaredDistance for #name #ty_generics #where_clause {
            #[allow(unused_variables, unused_imports)]
            #[inline]
            fn compute_squared_distance(
                &self,
                other: &Self,
            ) -> Result<crate::values::distance::SquaredDistance, ()> {
                if std::mem::discriminant(self) != std::mem::discriminant(other) {
                    return Err(());
                }
                match (self, other) {
                    #match_body
                }
            }
        }
    }
}

fn derive_variant_arm(
    variant: &synstructure::VariantInfo,
    mut where_clause: &mut Option<WhereClause>,
) -> TokenStream {
    let variant_attrs = cg::parse_variant_attrs_from_ast::<AnimationVariantAttrs>(&variant.ast());
    let (this_pattern, this_info) = cg::ref_pattern(&variant, "this");
    let (other_pattern, other_info) = cg::ref_pattern(&variant, "other");

    if variant_attrs.error {
        return quote! {
            (&#this_pattern, &#other_pattern) => Err(()),
        };
    }

    let sum = if this_info.is_empty() {
        quote! { crate::values::distance::SquaredDistance::from_sqrt(0.) }
    } else {
        let mut sum = quote!();
        sum.append_separated(this_info.iter().zip(&other_info).map(|(this, other)| {
            let field_attrs = cg::parse_field_attrs::<DistanceFieldAttrs>(&this.ast());
            if field_attrs.field_bound {
                let ty = &this.ast().ty;
                cg::add_predicate(
                    &mut where_clause,
                    parse_quote!(#ty: crate::values::distance::ComputeSquaredDistance),
                );
            }

            let animation_field_attrs =
                cg::parse_field_attrs::<AnimationFieldAttrs>(&this.ast());

            if animation_field_attrs.constant {
                quote! {
                    {
                        if #this != #other {
                            return Err(());
                        }
                        crate::values::distance::SquaredDistance::from_sqrt(0.)
                    }
                }
            } else {
                quote! {
                    crate::values::distance::ComputeSquaredDistance::compute_squared_distance(#this, #other)?
                }
            }
        }), quote!(+));
        sum
    };

    return quote! {
        (&#this_pattern, &#other_pattern) => Ok(#sum),
    };
}

#[derive(Default, FromField)]
#[darling(attributes(distance), default)]
struct DistanceFieldAttrs {
    field_bound: bool,
}