1use proc_macro::TokenStream;
 2use quote::quote;
 3use syn::{parse_macro_input, DeriveInput, GenericParam};
 4
 5pub fn derive_element(input: TokenStream) -> TokenStream {
 6    let ast = parse_macro_input!(input as DeriveInput);
 7    let type_name = ast.ident;
 8
 9    let mut state_type = quote! { () };
10
11    for param in &ast.generics.params {
12        if let GenericParam::Type(type_param) = param {
13            let type_ident = &type_param.ident;
14            state_type = quote! {#type_ident};
15            break;
16        }
17    }
18
19    let attrs = &ast.attrs;
20    for attr in attrs {
21        if attr.path.is_ident("element") {
22            match attr.parse_meta() {
23                Ok(syn::Meta::List(i)) => {
24                    for nested_meta in i.nested {
25                        if let syn::NestedMeta::Meta(syn::Meta::NameValue(nv)) = nested_meta {
26                            if nv.path.is_ident("view_state") {
27                                if let syn::Lit::Str(lit_str) = nv.lit {
28                                    state_type = lit_str.value().parse().unwrap();
29                                }
30                            }
31                        }
32                    }
33                }
34                _ => (),
35            }
36        }
37    }
38
39    let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
40
41    let gen = quote! {
42        impl #impl_generics gpui3::IntoAnyElement<#state_type> for #type_name #ty_generics
43        #where_clause
44        {
45            fn into_any(self) -> gpui3::AnyElement<#state_type> {
46                gpui3::AnyElement::new(self)
47            }
48        }
49
50        impl #impl_generics gpui3::Element for #type_name #ty_generics
51        #where_clause
52        {
53            type ViewState = #state_type;
54            type ElementState = gpui3::AnyElement<#state_type>;
55
56            fn element_id(&self) -> Option<gpui3::ElementId> {
57                // todo!("What should element_id be here?")
58                None
59            }
60
61            fn layout(
62                &mut self,
63                view_state: &mut Self::ViewState,
64                element_state: Option<Self::ElementState>,
65                cx: &mut gpui3::ViewContext<Self::ViewState>,
66            ) -> (gpui3::LayoutId, Self::ElementState) {
67                use gpui3::IntoAnyElement;
68
69                let mut rendered_element = self.render(view_state, cx).into_any();
70                let layout_id = rendered_element.layout(view_state, cx);
71                (layout_id, rendered_element)
72            }
73
74            fn paint(
75                &mut self,
76                bounds: gpui3::Bounds<gpui3::Pixels>,
77                view_state: &mut Self::ViewState,
78                element_state: &mut Self::ElementState,
79                cx: &mut gpui3::ViewContext<Self::ViewState>,
80            ) {
81                element_state.paint(view_state, None, cx)
82            }
83        }
84    };
85
86    gen.into()
87}