Lay foundation for a statically typed vdom

packages/yew-macro/Cargo.toml

@@ -17,6 +17,7 @@ proc-macro = true
 
 [dependencies]
 boolinator = "2"
+convert_case = "0.5"
 lazy_static = "1"
 proc-macro-error = "1"
 proc-macro2 = "1"

packages/yew-macro/src/lib.rs

@@ -52,6 +52,7 @@ mod function_component;
 mod html_tree;
 mod props;
 mod stringify;
+mod typed_vdom;
 
 use derive_props::DerivePropsInput;
 use function_component::{function_component_impl, FunctionComponent, FunctionComponentName};
@@ -134,3 +135,14 @@ pub fn function_component(
         .unwrap_or_else(|err| err.to_compile_error())
         .into()
 }
+
+/// Declares HTML element
+///
+/// Every HTML element is a component, which returns a manually constructed `VTag`.
+/// This macro is used to generate this component.
+#[proc_macro]
+pub fn generate_element(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let input = parse_macro_input!(input as typed_vdom::generate_element::GenerateElement);
+
+    input.to_token_stream().into()
+}

packages/yew-macro/src/typed_vdom/generate_element.rs

@@ -0,0 +1,103 @@
+use crate::typed_vdom::globals::global_attributes;
+use crate::typed_vdom::{kw, AttributePropDefinition};
+use convert_case::{Case, Casing};
+use proc_macro2::{Ident, TokenStream};
+use quote::{format_ident, quote, ToTokens};
+use syn::parse::{Parse, ParseStream};
+use syn::punctuated::Punctuated;
+use syn::{braced, Token};
+
+pub struct GenerateElement {
+    element_name: Ident,
+    props: Vec<AttributePropDefinition>,
+}
+
+impl Parse for GenerateElement {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        let name = input.parse()?;
+        let _separator = input.parse::<Token![;]>()?;
+
+        let props = {
+            let _props_kw = input.parse::<kw::props>()?;
+            let _separator = input.parse::<Token![:]>()?;
+
+            let buf;
+            let _brace_token = braced!(buf in input);
+            buf
+        };
+        let props: Punctuated<AttributePropDefinition, Token![,]> =
+            Punctuated::parse_terminated(&props)?;
+
+        Ok(Self {
+            element_name: name,
+            props: props.into_iter().collect(),
+        })
+    }
+}
+
+impl ToTokens for GenerateElement {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        let element_name = &self.element_name;
+        let mut prop_definitions = self.props.clone();
+        prop_definitions.extend(global_attributes());
+
+        let props_ident = format_ident!(
+            "{}Props",
+            element_name.to_string().to_case(Case::Pascal),
+            span = element_name.span()
+        );
+        let props = prop_definitions.iter().map(|it| it.build_fields());
+        let if_lets = prop_definitions.iter().map(|it| it.build_if_lets());
+
+        let out = quote! {
+            #[allow(non_camel_case_types)]
+            struct #element_name;
+
+            #[derive(::std::default::Default, ::std::clone::Clone, ::std::fmt::Debug, ::yew::html::Properties, ::std::cmp::PartialEq)]
+            struct #props_ident {
+                #(#props)*
+            }
+
+            impl #props_ident {
+                fn into_data(self) -> ElementData {
+
+                    ElementData {
+                        node_ref: ::std::option::Option::unwrap_or_default(self.node_ref),
+                        attributes: {
+                            let mut attrs = ::std::collections::HashMap::new();
+                            #(#if_lets)*
+                            attrs
+                        },
+                        listeners: ::std::default::Default::default(),
+                        key: self.key,
+                        children: self.children.map(|it| it.into_iter().collect()).unwrap_or_default()
+                    }
+                }
+            }
+
+            impl ::yew::Component for #element_name {
+                type Message = ();
+                type Properties = #props_ident;
+
+                fn create(_ctx: &::yew::html::Context<Self>) -> Self {
+                    Self
+                }
+
+                fn view(&self, ctx: &::yew::html::Context<Self>) -> ::yew::html::Html {
+                    let element: ElementData = ctx.props().clone().into_data();
+                    // todo use __new_{other, textarea, input} depending upon the element
+                    ::yew::virtual_dom::VTag::__new_other(
+                        ::std::stringify!(#element_name).into(),
+                        element.node_ref,
+                        element.key,
+                        ::yew::virtual_dom::Attributes::IndexMap(element.attributes.into_iter().collect()),
+                        ::yew::virtual_dom::Listeners::Pending(element.listeners.into_boxed_slice()),
+                        ::yew::virtual_dom::VList::with_children(element.children, ::std::option::Option::None),
+                    ).into()
+                }
+            }
+        };
+
+        tokens.extend(out);
+    }
+}

packages/yew-macro/src/typed_vdom/globals.rs

@@ -0,0 +1,75 @@
+use crate::typed_vdom::AttributePropDefinition;
+use syn::parse_quote;
+
+pub fn global_attributes() -> [AttributePropDefinition; 17] {
+    [
+        AttributePropDefinition::new(
+            parse_quote! { autocapitalize },
+            parse_quote! { ::yew::virtual_dom::AttrValue },
+        ),
+        AttributePropDefinition::new(
+            parse_quote! { contextmenu },
+            parse_quote! { ::yew::virtual_dom::AttrValue },
+        ),
+        AttributePropDefinition::new(
+            parse_quote! { contenteditable },
+            parse_quote! { ::yew::virtual_dom::AttrValue },
+        ),
+        AttributePropDefinition::new(
+            parse_quote! { slot },
+            parse_quote! { ::yew::virtual_dom::AttrValue },
+        ),
+        AttributePropDefinition::new(
+            parse_quote! { spellcheck },
+            parse_quote! { ::yew::virtual_dom::AttrValue },
+        ),
+        AttributePropDefinition::new(
+            parse_quote! { class },
+            parse_quote! { ::yew::virtual_dom::AttrValue },
+        ),
+        AttributePropDefinition::new(
+            parse_quote! { title },
+            parse_quote! { ::yew::virtual_dom::AttrValue },
+        ),
+        AttributePropDefinition::new(
+            parse_quote! { itemprop },
+            parse_quote! { ::yew::virtual_dom::AttrValue },
+        ),
+        AttributePropDefinition::new(
+            parse_quote! { accesskey },
+            parse_quote! { ::yew::virtual_dom::AttrValue },
+        ),
+        AttributePropDefinition::new(
+            parse_quote! { lang },
+            parse_quote! { ::yew::virtual_dom::AttrValue },
+        ),
+        AttributePropDefinition::new(
+            parse_quote! { id },
+            parse_quote! { ::yew::virtual_dom::AttrValue },
+        ),
+        AttributePropDefinition::new(
+            parse_quote! { translate },
+            parse_quote! { ::yew::virtual_dom::AttrValue },
+        ),
+        AttributePropDefinition::new(
+            parse_quote! { draggable },
+            parse_quote! { ::yew::virtual_dom::AttrValue },
+        ),
+        AttributePropDefinition::new(
+            parse_quote! { style },
+            parse_quote! { ::yew::virtual_dom::AttrValue },
+        ),
+        AttributePropDefinition::new(
+            parse_quote! { dir },
+            parse_quote! { ::yew::virtual_dom::AttrValue },
+        ),
+        AttributePropDefinition::new(
+            parse_quote! { tabindex },
+            parse_quote! { ::yew::virtual_dom::AttrValue },
+        ),
+        AttributePropDefinition::new(
+            parse_quote! { hidden },
+            parse_quote! { ::yew::virtual_dom::AttrValue },
+        ),
+    ]
+}

packages/yew-macro/src/typed_vdom/mod.rs

@@ -0,0 +1,60 @@
+use proc_macro2::{Ident, TokenStream};
+use quote::quote;
+use syn::parse::{Parse, ParseStream};
+use syn::{Token, Type};
+
+pub mod generate_element;
+mod globals;
+
+#[derive(Clone)]
+pub struct AttributePropDefinition {
+    name: Ident,
+    ty: Type,
+}
+
+impl Parse for AttributePropDefinition {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        let name = input.parse()?;
+        let _separator = input.parse::<Token![:]>();
+        let ty = input.parse()?;
+        Ok(Self { name, ty })
+    }
+}
+
+impl AttributePropDefinition {
+    pub fn new(name: Ident, ty: Type) -> Self {
+        Self { name, ty }
+    }
+    fn build_fields(&self) -> TokenStream {
+        let AttributePropDefinition { name, ty } = self;
+        quote! {
+            pub #name: ::std::option::Option::<#ty>,
+        }
+    }
+
+    fn _build_setter(&self) -> TokenStream {
+        let AttributePropDefinition { name, ty } = self;
+        quote! {
+            pub fn #name(&mut self, val: #ty) {
+                self.#name = ::std::option::Option::Some(val);
+            }
+        }
+    }
+
+    fn build_if_lets(&self) -> TokenStream {
+        let AttributePropDefinition { name, .. } = self;
+        if name == "children" || name == "key" || name == "node_ref" {
+            quote! {}
+        } else {
+            quote! {
+                if let Some(val) = self.#name {
+                    attrs.insert(::std::stringify!(#name), val);
+                }
+            }
+        }
+    }
+}
+
+pub(crate) mod kw {
+    syn::custom_keyword!(props);
+}

packages/yew/src/virtual_dom/mod.rs

@@ -4,6 +4,7 @@
 pub mod key;
 #[doc(hidden)]
 pub mod listeners;
+mod typings;
 #[doc(hidden)]
 pub mod vcomp;
 #[doc(hidden)]

packages/yew/src/virtual_dom/typings.rs

@@ -0,0 +1,54 @@
+//! This module contains the items required for a statically typed VDOM
+
+use std::collections::HashMap;
+use std::rc::Rc;
+
+use yew_macro::generate_element;
+
+use crate::virtual_dom::{AttrValue, Key, Listener, VNode};
+use crate::{Children, NodeRef};
+
+generate_element! {
+    button;
+    props: {
+        autofocus: AttrValue,
+        disabled: AttrValue,
+        form: AttrValue,
+        formaction: AttrValue,
+        formenctype: AttrValue,
+        formmethod: AttrValue,
+        formnovalidate: AttrValue,
+        formtarget: AttrValue,
+        name: AttrValue,
+        type_: AttrValue,
+        value: AttrValue,
+        node_ref: NodeRef,
+        key: Key,
+        children: Children,
+    }
+}
+
+/// Metadata of an HTML element
+///
+/// A [Component](crate::html::Component) is generated using this data for every element.
+#[derive(Debug)]
+pub struct ElementData {
+    node_ref: NodeRef,
+    attributes: HashMap<&'static str, AttrValue>,
+    listeners: Vec<Option<Rc<dyn Listener>>>,
+    key: Option<Key>,
+    children: Vec<VNode>,
+}
+
+
+#[cfg(test)]
+mod tests {
+    use crate::html;
+    fn _compiles() {
+        use super::button as Btn;
+
+        let _ = html! {
+            <Btn disabled="true" class="fuck" />
+        };
+    }
+}