Merge branch 'upstream' into fix-non-str-attributes

packages/core-macro/src/lib.rs

@@ -1,5 +1,6 @@
 use proc_macro::TokenStream;
 use quote::ToTokens;
+use rsx::RenderCallBody;
 use syn::parse_macro_input;
 
 mod inlineprops;
@@ -41,10 +42,7 @@ pub fn rsx(s: TokenStream) -> TokenStream {
 pub fn render(s: TokenStream) -> TokenStream {
     match syn::parse::<rsx::CallBody>(s) {
         Err(err) => err.to_compile_error().into(),
-        Ok(mut body) => {
-            body.inline_cx = true;
-            body.into_token_stream().into()
-        }
+        Ok(body) => RenderCallBody(body).into_token_stream().into(),
     }
 }
 

packages/native-core/src/real_dom.rs

@@ -174,7 +174,7 @@ impl<S: State> RealDom<S> {
             use dioxus_core::Mutation::*;
             match e {
                 AppendChildren { id, m } => {
-                    let children = self.stack.split_off(m);
+                    let children = self.stack.split_off(self.stack.len() - m);
                     let parent = self.element_to_node_id(id);
                     for child in children {
                         self.add_child(parent, child);
@@ -222,10 +222,10 @@ impl<S: State> RealDom<S> {
                     self.stack.push(clone_id);
                 }
                 ReplaceWith { id, m } => {
-                    let new_nodes = self.stack.split_off(m);
+                    let new_nodes = self.stack.split_off(self.stack.len() - m);
                     let old_node_id = self.element_to_node_id(id);
                     for new in new_nodes {
-                        self.tree.insert_after(old_node_id, new);
+                        self.tree.insert_before(old_node_id, new);
                         mark_dirty(new, NodeMask::ALL, &mut nodes_updated);
                     }
                     self.tree.remove(old_node_id);
@@ -234,21 +234,21 @@ impl<S: State> RealDom<S> {
                     let new_nodes = self.stack.split_off(self.stack.len() - m);
                     let old_node_id = self.load_child(path);
                     for new in new_nodes {
-                        self.tree.insert_after(old_node_id, new);
+                        self.tree.insert_before(old_node_id, new);
                         mark_dirty(new, NodeMask::ALL, &mut nodes_updated);
                     }
                     self.tree.remove(old_node_id);
                 }
                 InsertAfter { id, m } => {
-                    let new_nodes = self.stack.split_off(m);
+                    let new_nodes = self.stack.split_off(self.stack.len() - m);
                     let old_node_id = self.element_to_node_id(id);
-                    for new in new_nodes {
+                    for new in new_nodes.into_iter().rev() {
                         self.tree.insert_after(old_node_id, new);
                         mark_dirty(new, NodeMask::ALL, &mut nodes_updated);
                     }
                 }
                 InsertBefore { id, m } => {
-                    let new_nodes = self.stack.split_off(m);
+                    let new_nodes = self.stack.split_off(self.stack.len() - m);
                     let old_node_id = self.element_to_node_id(id);
                     for new in new_nodes {
                         self.tree.insert_before(old_node_id, new);

packages/native-core/src/utils/persistant_iterator.rs

@@ -73,11 +73,11 @@ impl PersistantElementIter {
             .edits
             .iter()
             .filter_map(|m| {
-                // nodes within templates will never be removedns
-                if let Mutation::Remove { id } = m {
-                    Some(rdom.element_to_node_id(*id))
-                } else {
-                    None
+                // nodes within templates will never be removed
+                match m {
+                    Mutation::Remove { id } => Some(rdom.element_to_node_id(*id)),
+                    Mutation::ReplaceWith { id, .. } => Some(rdom.element_to_node_id(*id)),
+                    _ => None,
                 }
             })
             .collect();
@@ -358,12 +358,16 @@ fn persist_removes() {
     let mut rdom: RealDom<Empty> = RealDom::new();
 
     let build = vdom.rebuild();
+    println!("{:#?}", build);
     let _to_update = rdom.apply_mutations(build);
 
     // this will end on the node that is removed
     let mut iter1 = PersistantElementIter::new();
     // this will end on the after node that is removed
     let mut iter2 = PersistantElementIter::new();
+    // root
+    iter1.next(&rdom).id();
+    iter2.next(&rdom).id();
     // div
     iter1.next(&rdom).id();
     iter2.next(&rdom).id();
@@ -386,27 +390,24 @@ fn persist_removes() {
 
     vdom.mark_dirty(ScopeId(0));
     let update = vdom.render_immediate();
+    println!("{:#?}", update);
     iter1.prune(&update, &rdom);
     iter2.prune(&update, &rdom);
     let _to_update = rdom.apply_mutations(update);
 
-    let p_tag = "1".to_string();
+    let root_tag = "Root".to_string();
     let idx = iter1.next(&rdom).id();
+    dbg!(&rdom[idx].node_data.node_type);
     assert!(matches!(
         &rdom[idx].node_data.node_type,
-        NodeType::Element { tag: p_tag, .. }
+        NodeType::Element { tag: root_tag, .. }
     ));
-    let text = "2".to_string();
-    let idx = iter1.next(&rdom).id();
-    assert!(matches!(
-        &rdom[idx].node_data.node_type,
-        NodeType::Text { text, .. }
-    ));
-    let div_tag = "div".to_string();
+
     let idx = iter2.next(&rdom).id();
+    dbg!(&rdom[idx].node_data.node_type);
     assert!(matches!(
         &rdom[idx].node_data.node_type,
-        NodeType::Element { tag: div_tag, .. }
+        NodeType::Element { tag: root_tag, .. }
     ));
 }
 

packages/rsx/src/lib.rs

@@ -37,9 +37,6 @@ use syn::{
 #[derive(Default, Debug)]
 pub struct CallBody {
     pub roots: Vec<BodyNode>,
-
-    // set this after
-    pub inline_cx: bool,
 }
 
 impl Parse for CallBody {
@@ -56,10 +53,7 @@ impl Parse for CallBody {
             roots.push(node);
         }
 
-        Ok(Self {
-            roots,
-            inline_cx: false,
-        })
+        Ok(Self { roots })
     }
 }
 
@@ -68,20 +62,29 @@ impl ToTokens for CallBody {
     fn to_tokens(&self, out_tokens: &mut TokenStream2) {
         let body = TemplateRenderer { roots: &self.roots };
 
-        if self.inline_cx {
-            out_tokens.append_all(quote! {
-                Some({
-                    let __cx = cx;
-                    #body
-                })
+        out_tokens.append_all(quote! {
+            ::dioxus::core::LazyNodes::new( move | __cx: &::dioxus::core::ScopeState| -> ::dioxus::core::VNode {
+                #body
             })
-        } else {
-            out_tokens.append_all(quote! {
-                ::dioxus::core::LazyNodes::new( move | __cx: &::dioxus::core::ScopeState| -> ::dioxus::core::VNode {
-                    #body
-                })
+        })
+    }
+}
+
+#[derive(Default, Debug)]
+pub struct RenderCallBody(pub CallBody);
+
+impl ToTokens for RenderCallBody {
+    fn to_tokens(&self, out_tokens: &mut TokenStream2) {
+        let body = TemplateRenderer {
+            roots: &self.0.roots,
+        };
+
+        out_tokens.append_all(quote! {
+            Some({
+                let __cx = cx;
+                #body
             })
-        }
+        })
     }
 }
 
@@ -111,7 +114,10 @@ impl<'a> ToTokens for TemplateRenderer<'a> {
         };
 
         let spndbg = format!("{:?}", self.roots[0].span());
-        let root_col = spndbg[9..].split("..").next().unwrap();
+        let root_col = spndbg
+            .rsplit_once("..")
+            .and_then(|(_, after)| after.split_once(')').map(|(before, _)| before))
+            .unwrap_or_default();
 
         let root_printer = self.roots.iter().enumerate().map(|(idx, root)| {
             context.current_path.push(idx as u8);
@@ -148,7 +154,6 @@ impl<'a> ToTokens for TemplateRenderer<'a> {
                 key: #key_tokens,
                 template: TEMPLATE,
                 root_ids: std::cell::Cell::from_mut( __cx.bump().alloc([None; #num_roots]) as &mut _).as_slice_of_cells(),
-                // root_ids: std::cell::Cell::from_mut( __cx.bump().alloc([None; #num_roots]) as &mut [::dioxus::core::ElementId]).as_slice_of_cells(),
                 dynamic_nodes: __cx.bump().alloc([ #( #node_printer ),* ]),
                 dynamic_attrs: __cx.bump().alloc([ #( #dyn_attr_printer ),* ]),
             }