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

use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, parse_quote, DeriveInput};

pub fn derive_component(input: TokenStream) -> TokenStream {
    let ast = parse_macro_input!(input as DeriveInput);
    let name = &ast.ident;

    let mut trait_generics = ast.generics.clone();
    let view_type = if let Some(view_type) = specified_view_type(&ast) {
        quote! { #view_type }
    } else {
        if let Some(first_type_param) = ast.generics.params.iter().find_map(|param| {
            if let syn::GenericParam::Type(type_param) = param {
                Some(type_param.ident.clone())
            } else {
                None
            }
        }) {
            quote! { #first_type_param }
        } else {
            trait_generics.params.push(parse_quote! { V: 'static });
            quote! { V }
        }
    };

    let (impl_generics, _, where_clause) = trait_generics.split_for_impl();
    let (_, ty_generics, _) = ast.generics.split_for_impl();

    let expanded = quote! {
        impl #impl_generics gpui::Component<#view_type> for #name #ty_generics #where_clause {
            fn render(self) -> gpui::AnyElement<#view_type> {
                (move |view_state: &mut #view_type, cx: &mut gpui::ViewContext<'_, #view_type>| self.render(view_state, cx))
                    .render()
            }
        }
    };

    TokenStream::from(expanded)
}

fn specified_view_type(ast: &DeriveInput) -> Option<proc_macro2::Ident> {
    let component_attr = ast
        .attrs
        .iter()
        .find(|attr| attr.path.is_ident("component"))?;

    if let Ok(syn::Meta::List(meta_list)) = component_attr.parse_meta() {
        meta_list.nested.iter().find_map(|nested| {
            if let syn::NestedMeta::Meta(syn::Meta::NameValue(nv)) = nested {
                if nv.path.is_ident("view_type") {
                    if let syn::Lit::Str(lit_str) = &nv.lit {
                        return Some(
                            lit_str
                                .parse::<syn::Ident>()
                                .expect("Failed to parse view_type"),
                        );
                    }
                }
            }
            None
        })
    } else {
        None
    }
}