rip out more lifetimes

packages/core/src/nodes.rs

@@ -19,9 +19,9 @@ pub type TemplateId = &'static str;
 ///
 /// Dioxus will do its best to immediately resolve any async components into a regular Element, but as an implementor
 /// you might need to handle the case where there's no node immediately ready.
-pub enum RenderReturn<'a> {
+pub enum RenderReturn {
     /// A currently-available element
-    Ready(VNode<'a>),
+    Ready(VNode),
 
     /// The component aborted rendering early. It might've thrown an error.
     ///
@@ -30,7 +30,7 @@ pub enum RenderReturn<'a> {
     Aborted(VPlaceholder),
 }
 
-impl<'a> Default for RenderReturn<'a> {
+impl Default for RenderReturn {
     fn default() -> Self {
         RenderReturn::Aborted(VPlaceholder::default())
     }
@@ -88,11 +88,11 @@ impl VNode {
 
     /// Create a new VNode
     pub fn new(
-        key: Option<&'a str>,
+        key: Option<String>,
         template: Template<'static>,
-        root_ids: bumpalo::collections::Vec<'a, ElementId>,
-        dynamic_nodes: &'a [DynamicNode<'a>],
-        dynamic_attrs: &'a [Attribute<'a>],
+        root_ids: Vec<ElementId>,
+        dynamic_nodes: &'a [DynamicNode],
+        dynamic_attrs: &'a [Attribute],
     ) -> Self {
         Self {
             key,
@@ -113,7 +113,7 @@ impl VNode {
     /// Load a dynamic root at the given index
     ///
     /// Returns [`None`] if the root is actually a static node (Element/Text)
-    pub fn dynamic_root(&self, idx: usize) -> Option<&'a DynamicNode<'a>> {
+    pub fn dynamic_root(&self, idx: usize) -> Option<&'a DynamicNode> {
         match &self.template.get().roots[idx] {
             TemplateNode::Element { .. } | TemplateNode::Text { text: _ } => None,
             TemplateNode::Dynamic { id } | TemplateNode::DynamicText { id } => {
@@ -147,7 +147,7 @@ pub struct Template<'a> {
     ///
     /// 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>],
+    pub roots: &'a [TemplateNode],
 
     /// The paths of each node relative to the root of the template.
     ///
@@ -242,7 +242,7 @@ impl<'a> Template<'a> {
     derive(serde::Serialize, serde::Deserialize),
     serde(tag = "type")
 )]
-pub enum TemplateNode<'a> {
+pub enum TemplateNode {
     /// An statically known element in the dom.
     ///
     /// In HTML this would be something like `<div id="123"> </div>`
@@ -250,7 +250,7 @@ pub enum TemplateNode<'a> {
         /// The name of the element
         ///
         /// IE for a div, it would be the string "div"
-        tag: &'a str,
+        tag: &'static str,
 
         /// The namespace of the element
         ///
@@ -260,23 +260,23 @@ pub enum TemplateNode<'a> {
             feature = "serialize",
             serde(deserialize_with = "deserialize_option_leaky")
         )]
-        namespace: Option<&'a str>,
+        namespace: Option<&'static str>,
 
         /// 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>],
+        attrs: &'static [TemplateAttribute],
 
         /// 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>],
+        children: &'static [TemplateNode],
     },
 
     /// This template node is just a piece of static text
     Text {
         /// The actual text
-        text: &'a str,
+        text: &'static str,
     },
 
     /// This template node is unknown, and needs to be created at runtime.
@@ -298,7 +298,7 @@ pub enum TemplateNode<'a> {
 ///
 /// This node's index in the DynamicNode list on VNode should match its repsective `Dynamic` index
 #[derive(Debug)]
-pub enum DynamicNode<'a> {
+pub enum DynamicNode {
     /// A component node
     ///
     /// Most of the time, Dioxus will actually know which component this is as compile time, but the props and
@@ -306,10 +306,10 @@ pub enum DynamicNode<'a> {
     ///
     /// The actual VComponent can be dynamic between two VNodes, though, allowing implementations to swap
     /// the render function at runtime
-    Component(VComponent<'a>),
+    Component(VComponent),
 
     /// A text node
-    Text(VText<'a>),
+    Text(VText),
 
     /// A placeholder
     ///
@@ -322,27 +322,20 @@ pub enum DynamicNode<'a> {
     ///
     /// Note that this is not a list of dynamic nodes. These must be VNodes and created through conditional rendering
     /// or iterators.
-    Fragment(&'a [VNode<'a>]),
+    Fragment(&'static [VNode]),
 }
 
-impl Default for DynamicNode<'_> {
+impl Default for DynamicNode {
     fn default() -> Self {
         Self::Placeholder(Default::default())
     }
 }
 
 /// An instance of a child component
-pub struct VComponent<'a> {
+pub struct VComponent {
     /// The name of this component
     pub name: &'static str,
 
-    /// Are the props valid for the 'static lifetime?
-    ///
-    /// Internally, this is used as a guarantee. Externally, this might be incorrect, so don't count on it.
-    ///
-    /// This flag is assumed by the [`crate::Properties`] trait which is unsafe to implement
-    pub(crate) static_props: bool,
-
     /// The assigned Scope for this component
     pub(crate) scope: Cell<Option<ScopeId>>,
 
@@ -351,17 +344,17 @@ pub struct VComponent<'a> {
     /// It is possible that components get folded at compile time, so these shouldn't be really used as a key
     pub(crate) render_fn: *const (),
 
-    pub(crate) props: RefCell<Option<Box<dyn AnyProps<'a> + 'a>>>,
+    pub(crate) props: RefCell<Option<Box<dyn AnyProps>>>,
 }
 
-impl<'a> VComponent<'a> {
+impl<'a> VComponent {
     /// Get the scope that this component is mounted to
     pub fn mounted_scope(&self) -> Option<ScopeId> {
         self.scope.get()
     }
 }
 
-impl<'a> std::fmt::Debug for VComponent<'a> {
+impl<'a> std::fmt::Debug for VComponent {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.debug_struct("VComponent")
             .field("name", &self.name)
@@ -373,17 +366,17 @@ impl<'a> std::fmt::Debug for VComponent<'a> {
 
 /// An instance of some text, mounted to the DOM
 #[derive(Debug)]
-pub struct VText<'a> {
+pub struct VText {
     /// The actual text itself
-    pub value: &'a str,
+    pub value: String,
 
     /// The ID of this node in the real DOM
     pub(crate) id: Cell<Option<ElementId>>,
 }
 
-impl<'a> VText<'a> {
+impl<'a> VText {
     /// Create a new VText
-    pub fn new(value: &'a str) -> Self {
+    pub fn new(value: String) -> Self {
         Self {
             value,
             id: Default::default(),
@@ -419,21 +412,21 @@ impl VPlaceholder {
     derive(serde::Serialize, serde::Deserialize),
     serde(tag = "type")
 )]
-pub enum TemplateAttribute<'a> {
+pub enum TemplateAttribute {
     /// This attribute is entirely known at compile time, enabling
     Static {
         /// The name of this attribute.
         ///
         /// For example, the `href` attribute in `href="https://example.com"`, would have the name "href"
-        name: &'a str,
+        name: &'static str,
 
         /// The value of this attribute, known at compile time
         ///
         /// Currently this only accepts &str, so values, even if they're known at compile time, are not known
-        value: &'a str,
+        value: &'static str,
 
         /// The namespace of this attribute. Does not exist in the HTML spec
-        namespace: Option<&'a str>,
+        namespace: Option<&'static str>,
     },
 
     /// The attribute in this position is actually determined dynamically at runtime
@@ -447,12 +440,12 @@ pub enum TemplateAttribute<'a> {
 
 /// An attribute on a DOM node, such as `id="my-thing"` or `href="https://example.com"`
 #[derive(Debug)]
-pub struct Attribute<'a> {
+pub struct Attribute {
     /// The name of the attribute.
-    pub name: &'a str,
+    pub name: &'static str,
 
     /// The value of the attribute
-    pub value: AttributeValue<'a>,
+    pub value: AttributeValue,
 
     /// The namespace of the attribute.
     ///
@@ -466,11 +459,11 @@ pub struct Attribute<'a> {
     pub(crate) mounted_element: Cell<ElementId>,
 }
 
-impl<'a> Attribute<'a> {
+impl Attribute {
     /// Create a new attribute
     pub fn new(
-        name: &'a str,
-        value: AttributeValue<'a>,
+        name: &'static str,
+        value: AttributeValue,
         namespace: Option<&'static str>,
         volatile: bool,
     ) -> Self {
@@ -493,9 +486,9 @@ impl<'a> Attribute<'a> {
 ///
 /// These are built-in to be faster during the diffing process. To use a custom value, use the [`AttributeValue::Any`]
 /// variant.
-pub enum AttributeValue<'a> {
+pub enum AttributeValue {
     /// Text attribute
-    Text(&'a str),
+    Text(String),
 
     /// A float
     Float(f64),
@@ -507,16 +500,16 @@ pub enum AttributeValue<'a> {
     Bool(bool),
 
     /// A listener, like "onclick"
-    Listener(RefCell<Option<ListenerCb<'a>>>),
+    Listener(RefCell<Option<ListenerCb>>),
 
     /// An arbitrary value that implements PartialEq and is static
-    Any(RefCell<Option<BumpBox<'a, dyn AnyValue>>>),
+    Any(RefCell<Option<Box<dyn AnyValue>>>),
 
     /// A "none" value, resulting in the removal of an attribute from the dom
     None,
 }
 
-pub type ListenerCb<'a> = BumpBox<'a, dyn FnMut(Event<dyn Any>) + 'a>;
+pub type ListenerCb = Box<dyn FnMut(Event<dyn Any>)>;
 
 /// Any of the built-in values that the Dioxus VirtualDom supports as dynamic attributes on elements that are borrowed
 ///
@@ -550,8 +543,8 @@ pub enum BorrowedAttributeValue<'a> {
     None,
 }
 
-impl<'a> From<&'a AttributeValue<'a>> for BorrowedAttributeValue<'a> {
-    fn from(value: &'a AttributeValue<'a>) -> Self {
+impl<'a> From<&'a AttributeValue> for BorrowedAttributeValue<'a> {
+    fn from(value: &'a AttributeValue) -> Self {
         match value {
             AttributeValue::Text(value) => BorrowedAttributeValue::Text(value),
             AttributeValue::Float(value) => BorrowedAttributeValue::Float(*value),
@@ -613,7 +606,7 @@ where
     panic!("Any cannot be deserialized")
 }
 
-impl<'a> std::fmt::Debug for AttributeValue<'a> {
+impl std::fmt::Debug for AttributeValue {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Self::Text(arg0) => f.debug_tuple("Text").field(arg0).finish(),
@@ -627,7 +620,7 @@ impl<'a> std::fmt::Debug for AttributeValue<'a> {
     }
 }
 
-impl<'a> PartialEq for AttributeValue<'a> {
+impl PartialEq for AttributeValue {
     fn eq(&self, other: &Self) -> bool {
         match (self, other) {
             (Self::Text(l0), Self::Text(r0)) => l0 == r0,
@@ -668,42 +661,33 @@ impl<T: Any + PartialEq + 'static> AnyValue for T {
     }
 }
 
-impl<'a> RenderReturn<'a> {
-    pub(crate) unsafe fn extend_lifetime_ref<'c>(&self) -> &'c RenderReturn<'c> {
-        unsafe { std::mem::transmute(self) }
-    }
-    pub(crate) unsafe fn extend_lifetime<'c>(self) -> RenderReturn<'c> {
-        unsafe { std::mem::transmute(self) }
-    }
-}
-
 /// A trait that allows various items to be converted into a dynamic node for the rsx macro
 pub trait IntoDynNode<'a, A = ()> {
     /// Consume this item along with a scopestate and produce a DynamicNode
     ///
     /// You can use the bump alloactor of the scopestate to creat the dynamic node
-    fn into_dyn_node(self, cx: &'a ScopeState) -> DynamicNode<'a>;
+    fn into_dyn_node(self, cx: &'a ScopeState) -> DynamicNode;
 }
 
 impl<'a> IntoDynNode<'a> for () {
-    fn into_dyn_node(self, _cx: &'a ScopeState) -> DynamicNode<'a> {
+    fn into_dyn_node(self, _cx: &'a ScopeState) -> DynamicNode {
         DynamicNode::default()
     }
 }
-impl<'a> IntoDynNode<'a> for VNode<'a> {
-    fn into_dyn_node(self, _cx: &'a ScopeState) -> DynamicNode<'a> {
+impl<'a> IntoDynNode<'a> for VNode {
+    fn into_dyn_node(self, _cx: &'a ScopeState) -> DynamicNode {
         DynamicNode::Fragment(_cx.bump().alloc([self]))
     }
 }
 
-impl<'a> IntoDynNode<'a> for DynamicNode<'a> {
-    fn into_dyn_node(self, _cx: &'a ScopeState) -> DynamicNode<'a> {
+impl<'a> IntoDynNode<'a> for DynamicNode {
+    fn into_dyn_node(self, _cx: &'a ScopeState) -> DynamicNode {
         self
     }
 }
 
 impl<'a, T: IntoDynNode<'a>> IntoDynNode<'a> for Option<T> {
-    fn into_dyn_node(self, _cx: &'a ScopeState) -> DynamicNode<'a> {
+    fn into_dyn_node(self, _cx: &'a ScopeState) -> DynamicNode {
         match self {
             Some(val) => val.into_dyn_node(_cx),
             None => DynamicNode::default(),
@@ -711,8 +695,8 @@ impl<'a, T: IntoDynNode<'a>> IntoDynNode<'a> for Option<T> {
     }
 }
 
-impl<'a> IntoDynNode<'a> for &Element<'a> {
-    fn into_dyn_node(self, _cx: &'a ScopeState) -> DynamicNode<'a> {
+impl<'a> IntoDynNode<'a> for &Element {
+    fn into_dyn_node(self, _cx: &'a ScopeState) -> DynamicNode {
         match self.as_ref() {
             Some(val) => val.clone().into_dyn_node(_cx),
             _ => DynamicNode::default(),
@@ -721,13 +705,13 @@ impl<'a> IntoDynNode<'a> for &Element<'a> {
 }
 
 impl<'a, 'b> IntoDynNode<'a> for LazyNodes<'a, 'b> {
-    fn into_dyn_node(self, cx: &'a ScopeState) -> DynamicNode<'a> {
+    fn into_dyn_node(self, cx: &'a ScopeState) -> DynamicNode {
         DynamicNode::Fragment(cx.bump().alloc([cx.render(self).unwrap()]))
     }
 }
 
 impl<'a, 'b> IntoDynNode<'b> for &'a str {
-    fn into_dyn_node(self, cx: &'b ScopeState) -> DynamicNode<'b> {
+    fn into_dyn_node(self, cx: &'b ScopeState) -> DynamicNode {
         DynamicNode::Text(VText {
             value: cx.bump().alloc_str(self),
             id: Default::default(),
@@ -745,13 +729,13 @@ impl IntoDynNode<'_> for String {
 }
 
 impl<'b> IntoDynNode<'b> for Arguments<'_> {
-    fn into_dyn_node(self, cx: &'b ScopeState) -> DynamicNode<'b> {
+    fn into_dyn_node(self, cx: &'b ScopeState) -> DynamicNode {
         cx.text_node(self)
     }
 }
 
-impl<'a> IntoDynNode<'a> for &'a VNode<'a> {
-    fn into_dyn_node(self, _cx: &'a ScopeState) -> DynamicNode<'a> {
+impl<'a> IntoDynNode<'a> for &'a VNode {
+    fn into_dyn_node(self, _cx: &'a ScopeState) -> DynamicNode {
         DynamicNode::Fragment(_cx.bump().alloc([VNode {
             parent: self.parent.clone(),
             stable_id: self.stable_id.clone(),
@@ -764,24 +748,24 @@ impl<'a> IntoDynNode<'a> for &'a VNode<'a> {
     }
 }
 
-pub trait IntoVNode<'a> {
-    fn into_vnode(self, _cx: &'a ScopeState) -> VNode<'a>;
+pub trait IntoVNode {
+    fn into_vnode(self) -> VNode;
 }
-impl<'a> IntoVNode<'a> for VNode<'a> {
-    fn into_vnode(self, _cx: &'a ScopeState) -> VNode<'a> {
+impl<'a> IntoVNode for VNode {
+    fn into_vnode(self) -> VNode {
         self
     }
 }
-impl<'a> IntoVNode<'a> for Element<'a> {
-    fn into_vnode(self, cx: &'a ScopeState) -> VNode<'a> {
+impl<'a> IntoVNode for Element {
+    fn into_vnode(self) -> VNode {
         match self {
             Some(val) => val.into_vnode(cx),
-            _ => VNode::empty(cx).unwrap(),
+            _ => VNode::empty().unwrap(),
         }
     }
 }
-impl<'a, 'b> IntoVNode<'a> for LazyNodes<'a, 'b> {
-    fn into_vnode(self, cx: &'a ScopeState) -> VNode<'a> {
+impl<'a, 'b> IntoVNode for LazyNodes<'a, 'b> {
+    fn into_vnode(self) -> VNode {
         cx.render(self).unwrap()
     }
 }
@@ -791,9 +775,9 @@ pub struct FromNodeIterator;
 impl<'a, T, I> IntoDynNode<'a, FromNodeIterator> for T
 where
     T: Iterator<Item = I>,
-    I: IntoVNode<'a>,
+    I: IntoVNode,
 {
-    fn into_dyn_node(self, cx: &'a ScopeState) -> DynamicNode<'a> {
+    fn into_dyn_node(self, cx: &'a ScopeState) -> DynamicNode {
         let mut nodes = bumpalo::collections::Vec::new_in(cx.bump());
 
         nodes.extend(self.into_iter().map(|node| node.into_vnode(cx)));