wip: fix issues with lifetimes

this commit fixes some lifetime issues regarding having to "move" data into the IntoVNode closure.

packages/core-macro/src/lib.rs

@@ -20,23 +20,6 @@ pub fn html(s: TokenStream) -> TokenStream {
     }
 }
 
-/// The html! macro makes it easy for developers to write jsx-style markup in their components.
-/// ```
-/// rsx! {
-///     div {
-///         class: "some special class"
-///         h1 { "Children too" }
-///     }
-/// }
-/// ```
-#[proc_macro]
-pub fn rsx(s: TokenStream) -> TokenStream {
-    match syn::parse::<rsx::RsxRender>(s) {
-        Err(e) => e.to_compile_error().into(),
-        Ok(s) => s.to_token_stream().into(),
-    }
-}
-
 /// 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]
@@ -97,3 +80,165 @@ pub fn derive_typed_builder(input: proc_macro::TokenStream) -> proc_macro::Token
         Err(error) => error.to_compile_error().into(),
     }
 }
+
+/// The html! macro makes it easy for developers to write jsx-style markup in their components.
+///
+/// ## Complete Reference Guide:
+/// ```
+/// const Example: FC<()> = |cx| {
+///     let formatting = "formatting!";
+///     let formatting_tuple = ("a", "b");
+///     let lazy_fmt = format_args!("lazily formatted text");
+///     cx.render(rsx! {
+///         div {
+///             // Elements
+///             div {}
+///             h1 {"Some text"}
+///             h1 {"Some text with {formatting}"}
+///             h1 {"Formatting basic expressions {formatting_tuple.0} and {formatting_tuple.1}"}
+///             h2 {
+///                 "Multiple"
+///                 "Text"
+///                 "Blocks"
+///                 "Use comments as separators in html"
+///             }
+///             div {
+///                 h1 {"multiple"}
+///                 h2 {"nested"}
+///                 h3 {"elements"}
+///             }
+///             div {
+///                 class: "my special div"
+///                 h1 {"Headers and attributes!"}
+///             }
+///             div {
+///                 // pass simple rust expressions in
+///                 class: lazy_fmt,
+///                 id: format_args!("attributes can be passed lazily with std::fmt::Arguments"),
+///                 div {
+///                     class: {
+///                         const WORD: &str = "expressions";
+///                         format_args!("Arguments can be passed in through curly braces for complex {}", WORD)
+///                     }
+///                 }
+///             }
+///
+///             // Expressions can be used in element position too:
+///             {rsx!(p { "More templating!" })}
+///             {html!(<p>"Even HTML templating!!"</p>)}
+///
+///             // Iterators
+///             {(0..10).map(|i| rsx!(li { "{i}" }))}
+///             {{
+///                 let data = std::collections::HashMap::<&'static str, &'static str>::new();
+///                 // Iterators *should* have keys when you can provide them.
+///                 // Keys make your app run faster. Make sure your keys are stable, unique, and predictable.
+///                 // Using an "ID" associated with your data is a good idea.
+///                 data.into_iter().map(|(k, v)| rsx!(li { key: "{k}" "{v}" }))
+///             }}
+///            
+///             // Matching
+///             // Matching will throw a Rust error about "no two closures are the same type"
+///             // To fix this, call "render" method or use the "in" syntax to produce VNodes.
+///             // There's nothing we can do about it, sorry :/ (unless you want *really* unhygenic macros)
+///             {match true {
+///                 true => rsx!(in cx, h1 {"Top text"}),
+///                 false => cx.render(rsx!( h1 {"Bottom text"}))
+///             }}
+///
+///             // Conditional rendering
+///             // Dioxus conditional rendering is based around None/Some. We have no special syntax for conditionals.
+///             // You can convert a bool condition to rsx! with .then and .or
+///             {true.then(|| rsx!(div {}))}
+///
+///             // True conditions need to be rendered (same reasons as matching)
+///             {if true {
+///                 rsx!(in cx, h1 {"Top text"})
+///             } else {
+///                 rsx!(in cx, h1 {"Bottom text"})
+///             }}
+///
+///             // returning "None" is a bit noisy... but rare in practice
+///             {None as Option<()>}
+///
+///             // Use the Dioxus type-alias for less noise
+///             {NONE_ELEMENT}
+///
+///             // can also just use empty fragments
+///             Fragment {}
+///
+///             // Fragments let you insert groups of nodes without a parent.
+///             // This lets you make components that insert elements as siblings without a container.
+///             div {"A"}
+///             Fragment {
+///                 div {"B"}
+///                 div {"C"}
+///                 Fragment {
+///                     "D"
+///                     Fragment {
+///                         "heavily nested fragments is an antipattern"
+///                         "they cause Dioxus to do unnecessary work"
+///                         "don't use them carelessly if you can help it"
+///                     }
+///                 }
+///             }
+///
+///             // Components
+///             // Can accept any paths
+///             // Notice how you still get syntax highlighting and IDE support :)
+///             Baller {}
+///             baller::Baller { }
+///             crate::baller::Baller {}
+///
+///             // Can take properties
+///             Taller { a: "asd" }
+///
+///             // Can take optional properties
+///             Taller { a: "asd" }
+///
+///             // Can pass in props directly as an expression
+///             {{
+///                 let props = TallerProps {a: "hello"};
+///                 rsx!(Taller { ..props })
+///             }}
+///
+///             // Spreading can also be overridden manually
+///             Taller {
+///                 ..TallerProps { a: "ballin!" }
+///                 a: "not ballin!"
+///             }
+///
+///             // Can take children too!
+///             Taller { a: "asd", div {"hello world!"} }
+///         }
+///     })
+/// };
+///
+/// mod baller {
+///     use super::*;
+///     pub struct BallerProps {}
+///
+///     /// This component totally balls
+///     pub fn Baller(cx: Context<()>) -> VNode {
+///         todo!()
+///     }
+/// }
+///
+/// #[derive(Debug, PartialEq, Props)]
+/// pub struct TallerProps {
+///     a: &'static str,
+/// }
+///
+/// /// This component is taller than most :)
+/// pub fn Taller(cx: Context<TallerProps>) -> VNode {
+///     let b = true;
+///     todo!()
+/// }
+/// ```
+#[proc_macro]
+pub fn rsx(s: TokenStream) -> TokenStream {
+    match syn::parse::<rsx::RsxRender>(s) {
+        Err(e) => e.to_compile_error().into(),
+        Ok(s) => s.to_token_stream().into(),
+    }
+}

packages/core-macro/src/rsx/element.rs

@@ -25,7 +25,7 @@ impl ToTokens for Element {
         // let name = &self.name.to_string();
 
         tokens.append_all(quote! {
-            __cx.element(#name)
+            __cx.element(dioxus_elements::#name)
         });
 
         // Add attributes

packages/core-macro/src/rsx/mod.rs

@@ -80,7 +80,7 @@ impl ToTokens for RsxRender {
             quote! {#inner}
         } else {
             let childs = &self.roots;
-            quote! { __cx.fragment_from_iter(&[ #(#childs),* ]) }
+            quote! { __cx.fragment_from_iter([ #(#childs),* ]) }
         };
 
         match &self.custom_context {