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

packages/core/src/nodes.rs

@@ -5,7 +5,7 @@ use bumpalo::boxed::Box as BumpBox;
 use bumpalo::Bump;
 use std::{
     any::{Any, TypeId},
-    cell::{Cell, RefCell},
+    cell::{Cell, RefCell, UnsafeCell},
     fmt::Arguments,
     future::Future,
     ops::Deref,
@@ -22,10 +22,22 @@ pub type TemplateId = &'static str;
 /// you might need to handle the case where there's no node immediately ready.
 pub enum RenderReturn<'a> {
     /// A currently-available element
-    Sync(Element<'a>),
+    Ready(VNode<'a>),
+
+    /// The component aborted rendering early. It might've thrown an error.
+    ///
+    /// In its place we've produced a placeholder to locate its spot in the dom when
+    /// it recovers.
+    Aborted(VPlaceholder),
 
     /// An ongoing future that will resolve to a [`Element`]
-    Async(BumpBox<'a, dyn Future<Output = Element<'a>> + 'a>),
+    Pending(BumpBox<'a, dyn Future<Output = Element<'a>> + 'a>),
+}
+
+impl<'a> Default for RenderReturn<'a> {
+    fn default() -> Self {
+        RenderReturn::Aborted(VPlaceholder::default())
+    }
 }
 
 /// A reference to a template along with any context needed to hydrate it
@@ -43,11 +55,11 @@ pub struct VNode<'a> {
     pub parent: Option<ElementId>,
 
     /// The static nodes and static descriptor of the template
-    pub template: Template<'static>,
+    pub template: Cell<Template<'static>>,
 
     /// The IDs for the roots of this template - to be used when moving the template around and removing it from
     /// the actual Dom
-    pub root_ids: &'a [Cell<Option<ElementId>>],
+    pub root_ids: BoxedCellSlice,
 
     /// The dynamic parts of the template
     pub dynamic_nodes: &'a [DynamicNode<'a>],
@@ -56,21 +68,120 @@ pub struct VNode<'a> {
     pub dynamic_attrs: &'a [Attribute<'a>],
 }
 
+// Saftey: There is no way to get references to the internal data of this struct so no refrences will be invalidated by mutating the data with a immutable reference (The same principle behind Cell)
+#[derive(Debug, Default)]
+pub struct BoxedCellSlice(UnsafeCell<Option<Box<[ElementId]>>>);
+
+impl Clone for BoxedCellSlice {
+    fn clone(&self) -> Self {
+        Self(UnsafeCell::new(unsafe { (*self.0.get()).clone() }))
+    }
+}
+
+impl BoxedCellSlice {
+    pub fn last(&self) -> Option<ElementId> {
+        unsafe {
+            (*self.0.get())
+                .as_ref()
+                .and_then(|inner| inner.as_ref().last().copied())
+        }
+    }
+
+    pub fn get(&self, idx: usize) -> Option<ElementId> {
+        unsafe {
+            (*self.0.get())
+                .as_ref()
+                .and_then(|inner| inner.as_ref().get(idx).copied())
+        }
+    }
+
+    pub unsafe fn get_unchecked(&self, idx: usize) -> Option<ElementId> {
+        (*self.0.get())
+            .as_ref()
+            .and_then(|inner| inner.as_ref().get(idx).copied())
+    }
+
+    pub fn set(&self, idx: usize, new: ElementId) {
+        unsafe {
+            if let Some(inner) = &mut *self.0.get() {
+                inner[idx] = new;
+            }
+        }
+    }
+
+    pub fn intialize(&self, contents: Box<[ElementId]>) {
+        unsafe {
+            *self.0.get() = Some(contents);
+        }
+    }
+
+    pub fn transfer(&self, other: &Self) {
+        unsafe {
+            *self.0.get() = (*other.0.get()).clone();
+        }
+    }
+
+    pub fn take_from(&self, other: &Self) {
+        unsafe {
+            *self.0.get() = (*other.0.get()).take();
+        }
+    }
+
+    pub fn len(&self) -> usize {
+        unsafe {
+            (*self.0.get())
+                .as_ref()
+                .map(|inner| inner.len())
+                .unwrap_or(0)
+        }
+    }
+}
+
+impl<'a> IntoIterator for &'a BoxedCellSlice {
+    type Item = ElementId;
+
+    type IntoIter = BoxedCellSliceIter<'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        BoxedCellSliceIter {
+            index: 0,
+            borrow: self,
+        }
+    }
+}
+
+pub struct BoxedCellSliceIter<'a> {
+    index: usize,
+    borrow: &'a BoxedCellSlice,
+}
+
+impl Iterator for BoxedCellSliceIter<'_> {
+    type Item = ElementId;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let result = self.borrow.get(self.index);
+        if result.is_some() {
+            self.index += 1;
+        }
+        result
+    }
+}
+
 impl<'a> VNode<'a> {
     /// Create a template with no nodes that will be skipped over during diffing
     pub fn empty() -> Element<'a> {
         Some(VNode {
             key: None,
             parent: None,
-            root_ids: &[],
+            root_ids: BoxedCellSlice::default(),
             dynamic_nodes: &[],
             dynamic_attrs: &[],
-            template: Template {
+            template: Cell::new(Template {
                 name: "dioxus-empty",
                 roots: &[],
                 node_paths: &[],
                 attr_paths: &[],
-            },
+            }),
         })
     }
 
@@ -78,7 +189,7 @@ impl<'a> VNode<'a> {
     ///
     /// Returns [`None`] if the root is actually a static node (Element/Text)
     pub fn dynamic_root(&self, idx: usize) -> Option<&'a DynamicNode<'a>> {
-        match &self.template.roots[idx] {
+        match &self.template.get().roots[idx] {
             TemplateNode::Element { .. } | TemplateNode::Text { text: _ } => None,
             TemplateNode::Dynamic { id } | TemplateNode::DynamicText { id } => {
                 Some(&self.dynamic_nodes[*id])
@@ -103,32 +214,85 @@ impl<'a> VNode<'a> {
 ///
 /// For this to work properly, the [`Template::name`] *must* be unique across your entire project. This can be done via variety of
 /// ways, with the suggested approach being the unique code location (file, line, col, etc).
-#[cfg_attr(feature = "serialize", derive(serde::Serialize))]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
 #[derive(Debug, Clone, Copy, PartialEq, Hash, Eq, PartialOrd, Ord)]
 pub struct Template<'a> {
     /// The name of the template. This must be unique across your entire program for template diffing to work properly
     ///
     /// If two templates have the same name, it's likely that Dioxus will panic when diffing.
+    #[cfg_attr(
+        feature = "serialize",
+        serde(deserialize_with = "deserialize_string_leaky")
+    )]
     pub name: &'a str,
 
     /// The list of template nodes that make up the template
     ///
     /// Unlike react, calls to `rsx!` can have multiple roots. This list supports that paradigm.
+    #[cfg_attr(feature = "serialize", serde(deserialize_with = "deserialize_leaky"))]
     pub roots: &'a [TemplateNode<'a>],
 
     /// The paths of each node relative to the root of the template.
     ///
     /// These will be one segment shorter than the path sent to the renderer since those paths are relative to the
     /// topmost element, not the `roots` field.
+    #[cfg_attr(
+        feature = "serialize",
+        serde(deserialize_with = "deserialize_bytes_leaky")
+    )]
     pub node_paths: &'a [&'a [u8]],
 
     /// The paths of each dynamic attribute relative to the root of the template
     ///
     /// These will be one segment shorter than the path sent to the renderer since those paths are relative to the
     /// topmost element, not the `roots` field.
+    #[cfg_attr(
+        feature = "serialize",
+        serde(deserialize_with = "deserialize_bytes_leaky")
+    )]
     pub attr_paths: &'a [&'a [u8]],
 }
 
+#[cfg(feature = "serialize")]
+fn deserialize_string_leaky<'a, 'de, D>(deserializer: D) -> Result<&'a str, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    use serde::Deserialize;
+
+    let deserialized = String::deserialize(deserializer)?;
+    Ok(&*Box::leak(deserialized.into_boxed_str()))
+}
+
+#[cfg(feature = "serialize")]
+fn deserialize_bytes_leaky<'a, 'de, D>(deserializer: D) -> Result<&'a [&'a [u8]], D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    use serde::Deserialize;
+
+    let deserialized = Vec::<Vec<u8>>::deserialize(deserializer)?;
+    let deserialized = deserialized
+        .into_iter()
+        .map(|v| &*Box::leak(v.into_boxed_slice()))
+        .collect::<Vec<_>>();
+    Ok(&*Box::leak(deserialized.into_boxed_slice()))
+}
+
+#[cfg(feature = "serialize")]
+fn deserialize_leaky<'a, 'de, T: serde::Deserialize<'de>, D>(
+    deserializer: D,
+) -> Result<&'a [T], D::Error>
+where
+    T: serde::Deserialize<'de>,
+    D: serde::Deserializer<'de>,
+{
+    use serde::Deserialize;
+
+    let deserialized = Box::<[T]>::deserialize(deserializer)?;
+    Ok(&*Box::leak(deserialized))
+}
+
 impl<'a> Template<'a> {
     /// Is this template worth caching at all, since it's completely runtime?
     ///
@@ -145,7 +309,11 @@ impl<'a> Template<'a> {
 ///
 /// This can be created at compile time, saving the VirtualDom time when diffing the tree
 #[derive(Debug, Clone, Copy, PartialEq, Hash, Eq, PartialOrd, Ord)]
-#[cfg_attr(feature = "serialize", derive(serde::Serialize), serde(tag = "type"))]
+#[cfg_attr(
+    feature = "serialize",
+    derive(serde::Serialize, serde::Deserialize),
+    serde(tag = "type")
+)]
 pub enum TemplateNode<'a> {
     /// An statically known element in the dom.
     ///
@@ -165,9 +333,11 @@ pub enum TemplateNode<'a> {
         /// A list of possibly dynamic attribues for this element
         ///
         /// An attribute on a DOM node, such as `id="my-thing"` or `href="https://example.com"`.
+        #[cfg_attr(feature = "serialize", serde(deserialize_with = "deserialize_leaky"))]
         attrs: &'a [TemplateAttribute<'a>],
 
         /// A list of template nodes that define another set of template nodes
+        #[cfg_attr(feature = "serialize", serde(deserialize_with = "deserialize_leaky"))]
         children: &'a [TemplateNode<'a>],
     },
 
@@ -544,7 +714,10 @@ pub trait ComponentReturn<'a, A = ()> {
 
 impl<'a> ComponentReturn<'a> for Element<'a> {
     fn into_return(self, _cx: &ScopeState) -> RenderReturn<'a> {
-        RenderReturn::Sync(self)
+        match self {
+            Some(node) => RenderReturn::Ready(node),
+            None => RenderReturn::default(),
+        }
     }
 }
 
@@ -556,7 +729,7 @@ where
 {
     fn into_return(self, cx: &'a ScopeState) -> RenderReturn<'a> {
         let f: &mut dyn Future<Output = Element<'a>> = cx.bump().alloc(self);
-        RenderReturn::Async(unsafe { BumpBox::from_raw(f) })
+        RenderReturn::Pending(unsafe { BumpBox::from_raw(f) })
     }
 }
 
@@ -640,8 +813,8 @@ impl<'a> IntoDynNode<'a> for &'a VNode<'a> {
     fn into_vnode(self, _cx: &'a ScopeState) -> DynamicNode<'a> {
         DynamicNode::Fragment(_cx.bump().alloc([VNode {
             parent: self.parent,
-            template: self.template,
-            root_ids: self.root_ids,
+            template: self.template.clone(),
+            root_ids: self.root_ids.clone(),
             key: self.key,
             dynamic_nodes: self.dynamic_nodes,
             dynamic_attrs: self.dynamic_attrs,