Feat: massive changes to definition of components

This change switches back to the original `ctx<props>` syntax for
commponents. This lets lifetime elision to remove the need to match
exactly which lifetime (props or ctx) gets  carried to the output. As
such, `Props` is currently required to be static. It *is* possible to
loosen this restriction, and will be done in the future, though only
through adding metadata about the props through the Props derive
macro. Implementing the IS_STATIC trait is unsafe, so the derive macro
will do it through some heuristics.

For now, this unlocks sharing vnodes from parents to children, enabling
pass-thru components, fragments, portals, etc.

packages/core-macro/src/fc.rs

@@ -5,9 +5,7 @@ use syn::{
     parse::{Parse, ParseStream},
     Signature,
 };
-use syn::{
-    Attribute, Block, FnArg, Ident, Item, ItemFn, ReturnType, Type, Visibility,
-};
+use syn::{Attribute, Block, FnArg, Ident, Item, ItemFn, ReturnType, Type, Visibility};
 
 /// A parsed version of the user's input
 pub struct FunctionComponent {
@@ -135,7 +133,7 @@ impl ToTokens for FunctionComponent {
             }
 
             impl<'a> FC for #function_name<'a> {
-                fn render(ctx: Context<'_>, props: &#function_name<'a>) -> DomTree {
+                fn render(ctx: Context<'_>, props: &#function_name<'a>) -> VNode {
                     let #function_name {
                         ..
                     } = props;
@@ -244,7 +242,7 @@ pub fn ensure_return_type(output: ReturnType) -> syn::Result<Box<Type>> {
     match output {
         ReturnType::Default => Err(syn::Error::new_spanned(
             output,
-            "function components must return a `DomTree`",
+            "function components must return a `VNode`",
         )),
         ReturnType::Type(_, ty) => Ok(ty),
     }

packages/core-macro/src/lib.rs

@@ -40,6 +40,16 @@ pub fn rsx_template(s: TokenStream) -> TokenStream {
     }
 }
 
+/// The html! macro makes it easy for developers to write jsx-style markup in their components.
+/// We aim to keep functional parity with html templates.
+#[proc_macro]
+pub fn html_template(s: TokenStream) -> TokenStream {
+    match syn::parse::<rsxtemplate::RsxTemplate>(s) {
+        Err(e) => e.to_compile_error().into(),
+        Ok(s) => s.to_token_stream().into(),
+    }
+}
+
 // #[proc_macro_attribute]
 // pub fn fc(attr: TokenStream, item: TokenStream) -> TokenStream {
 
@@ -51,7 +61,7 @@ pub fn rsx_template(s: TokenStream) -> TokenStream {
 /// ```ignore
 ///
 /// #[fc]
-/// fn Example(ctx: Context, name: &str) -> DomTree {
+/// fn Example(ctx: Context, name: &str) -> VNode {
 ///     ctx.render(rsx! { h1 {"hello {name}"} })
 /// }
 /// ```

packages/core-macro/src/rsxtemplate.rs

@@ -22,7 +22,19 @@ impl Parse for RsxTemplate {
     fn parse(s: ParseStream) -> Result<Self> {
         if s.peek(LitStr) {
             use std::str::FromStr;
+
             let lit = s.parse::<LitStr>()?;
+            let g = lit.span();
+            let mut value = lit.value();
+            if value.ends_with('\n') {
+                value.pop();
+                if value.ends_with('\r') {
+                    value.pop();
+                }
+            }
+            let lit = LitStr::new(&value, lit.span());
+
+            // panic!("{:#?}", lit);
             match lit.parse::<crate::rsxt::RsxRender>() {
                 Ok(r) => Ok(Self { inner: r }),
                 Err(e) => Err(e),