Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Checkpoint

Browse source
This commit is contained in:
Nathan Sobo 2023-08-22 09:07:45 -06:00
parent ff7b25c538
commit 53679ce045
8 changed files with 228 additions and 263 deletions
Download patch file Download diff file Expand all files Collapse all files

122
crates/gpui/playground_macros/src/derive_element.rs
View file

@ -1,72 +1,57 @@
use proc_macro::TokenStream;
use quote::{format_ident, quote};
use syn::{
parse_macro_input, parse_quote, DeriveInput, GenericParam, Generics, Ident, Lit, Meta,
WhereClause,
};
use proc_macro2::Ident;
use quote::quote;
use syn::{parse_macro_input, parse_quote, DeriveInput, GenericParam, Generics};
use crate::derive_into_element::impl_into_element;
pub fn derive_element(input: TokenStream) -> TokenStream {
let ast = parse_macro_input!(input as DeriveInput);
let type_name = ast.ident;
let placeholder_view_generics: Generics = parse_quote! { <V: 'static> };
let crate_name: String = ast
.attrs
.iter()
.find_map(|attr| {
if attr.path.is_ident("element_crate") {
match attr.parse_meta() {
Ok(Meta::NameValue(nv)) => {
if let Lit::Str(s) = nv.lit {
Some(s.value())
} else {
None
}
}
_ => None,
}
let (impl_generics, type_generics, where_clause, view_type_name, lifetimes) =
if let Some(first_type_param) = ast.generics.params.iter().find_map(|param| {
if let GenericParam::Type(type_param) = param {
Some(type_param.ident.clone())
} else {
None
}
})
.unwrap_or_else(|| String::from("playground"));
let crate_name = format_ident!("{}", crate_name);
let placeholder_view_generics: Generics = parse_quote! { <V: 'static> };
let placeholder_view_type_name: Ident = parse_quote! { V };
let view_type_name: Ident;
let impl_generics: syn::ImplGenerics<'_>;
let type_generics: Option<syn::TypeGenerics<'_>>;
let where_clause: Option<&'_ WhereClause>;
match ast.generics.params.iter().find_map(|param| {
if let GenericParam::Type(type_param) = param {
Some(type_param.ident.clone())
} else {
None
}
}) {
Some(type_name) => {
view_type_name = type_name;
}) {
let mut lifetimes = vec![];
for param in ast.generics.params.iter() {
if let GenericParam::Lifetime(lifetime_def) = param {
lifetimes.push(lifetime_def.lifetime.clone());
}
}
let generics = ast.generics.split_for_impl();
impl_generics = generics.0;
type_generics = Some(generics.1);
where_clause = generics.2;
}
_ => {
view_type_name = placeholder_view_type_name;
(
generics.0,
Some(generics.1),
generics.2,
first_type_param,
lifetimes,
)
} else {
let generics = placeholder_view_generics.split_for_impl();
impl_generics = generics.0;
type_generics = None;
where_clause = generics.2;
}
}
let placeholder_view_type_name: Ident = parse_quote! { V };
(
generics.0,
None,
generics.2,
placeholder_view_type_name,
vec![],
)
};
let lifetimes = if !lifetimes.is_empty() {
quote! { <#(#lifetimes),*> }
} else {
quote! {}
};
let impl_into_element = impl_into_element(
&impl_generics,
&crate_name,
&view_type_name,
&type_name,
&type_generics,
@ -74,37 +59,28 @@ pub fn derive_element(input: TokenStream) -> TokenStream {
);
let gen = quote! {
impl #impl_generics #crate_name::element::Element<#view_type_name> for #type_name #type_generics
impl #impl_generics playground::element::Element<#view_type_name> for #type_name #type_generics
#where_clause
{
type Layout = #crate_name::element::AnyElement<V>;
fn declared_style(&mut self) -> &mut #crate_name::style::StyleRefinement {
&mut self.metadata.style
}
fn handlers_mut(&mut self) -> &mut Vec<#crate_name::element::EventHandler<V>> {
&mut self.metadata.handlers
}
type Layout = Option<playground::element::AnyElement<#view_type_name #lifetimes>>;
fn layout(
&mut self,
view: &mut V,
cx: &mut #crate_name::element::LayoutContext<V>,
) -> anyhow::Result<(taffy::tree::NodeId, Self::Layout)> {
cx: &mut playground::element::LayoutContext<V>,
) -> anyhow::Result<playground::element::Layout<V, Self::Layout>> {
let mut element = self.render(view, cx).into_any();
let node_id = element.layout(view, cx)?;
Ok((node_id, element))
let layout_id = element.layout(view, cx)?;
Ok(playground::element::Layout::new(layout_id, Some(element)))
}
fn paint<'a>(
fn paint(
&mut self,
layout: #crate_name::element::Layout<'a, Self::Layout>,
view: &mut V,
cx: &mut #crate_name::element::PaintContext<V>,
) -> anyhow::Result<()> {
layout.from_element.paint(view, cx)?;
Ok(())
layout: &mut playground::element::Layout<V, Self::Layout>,
cx: &mut playground::element::PaintContext<V>,
) {
layout.paint(view, cx);
}
}

31
crates/gpui/playground_macros/src/derive_into_element.rs
View file

@ -1,36 +1,13 @@
use proc_macro::TokenStream;
use quote::{format_ident, quote};
use quote::quote;
use syn::{
parse_macro_input, parse_quote, DeriveInput, GenericParam, Generics, Ident, Lit, Meta,
WhereClause,
parse_macro_input, parse_quote, DeriveInput, GenericParam, Generics, Ident, WhereClause,
};
pub fn derive_into_element(input: TokenStream) -> TokenStream {
let ast = parse_macro_input!(input as DeriveInput);
let type_name = ast.ident;
let crate_name: String = ast
.attrs
.iter()
.find_map(|attr| {
if attr.path.is_ident("element_crate") {
match attr.parse_meta() {
Ok(Meta::NameValue(nv)) => {
if let Lit::Str(s) = nv.lit {
Some(s.value())
} else {
None
}
}
_ => None,
}
} else {
None
}
})
.unwrap_or_else(|| String::from("playground"));
let crate_name = format_ident!("{}", crate_name);
let placeholder_view_generics: Generics = parse_quote! { <V: 'static> };
let placeholder_view_type_name: Ident = parse_quote! { V };
let view_type_name: Ident;
@ -63,7 +40,6 @@ pub fn derive_into_element(input: TokenStream) -> TokenStream {
impl_into_element(
&impl_generics,
&crate_name,
&view_type_name,
&type_name,
&type_generics,
@ -74,14 +50,13 @@ pub fn derive_into_element(input: TokenStream) -> TokenStream {
pub fn impl_into_element(
impl_generics: &syn::ImplGenerics<'_>,
crate_name: &Ident,
view_type_name: &Ident,
type_name: &Ident,
type_generics: &Option<syn::TypeGenerics<'_>>,
where_clause: &Option<&WhereClause>,
) -> proc_macro2::TokenStream {
quote! {
impl #impl_generics #crate_name::element::IntoElement<#view_type_name> for #type_name #type_generics
impl #impl_generics playground::element::IntoElement<#view_type_name> for #type_name #type_generics
#where_clause
{
type Element = Self;