Revert "Allow iterating over ref of ChildrenRenderer"

cecton · cecton · commit 2401701e590a · 2023-11-01T18:14:32.000+01:00
This reverts commit 71bcd09.
diff --git a/packages/yew/src/html/component/children.rs b/packages/yew/src/html/component/children.rs
@@ -3,10 +3,7 @@
 use std::fmt;
 use std::rc::Rc;
 
-use implicit_clone::{unsync::IArray, ImplicitClone};
-
 use crate::html::Html;
-use crate::utils::RcExt;
 use crate::virtual_dom::{VChild, VComp, VList, VNode};
 use crate::{BaseComponent, Properties};
 
@@ -155,27 +152,23 @@ pub type ChildrenWithProps<CHILD> = ChildrenRenderer<VChild<CHILD>>;
 
 /// A type used for rendering children html.
 #[derive(Clone)]
-pub struct ChildrenRenderer<T: Clone + 'static> {
-    pub(crate) children: IArray<Rc<T>>,
+pub struct ChildrenRenderer<T> {
+    pub(crate) children: Vec<T>,
 }
 
-impl<T: Clone> ImplicitClone for ChildrenRenderer<T> {}
-
-impl<T: Clone + PartialEq> PartialEq for ChildrenRenderer<T> {
+impl<T: PartialEq> PartialEq for ChildrenRenderer<T> {
     fn eq(&self, other: &Self) -> bool {
         self.children == other.children
     }
 }
 
 impl<T> ChildrenRenderer<T>
 where
-    T: Clone + 'static,
+    T: Clone,
 {
     /// Create children
     pub fn new(children: Vec<T>) -> Self {
-        Self {
-            children: children.into_iter().map(Rc::new).collect(),
-        }
+        Self { children }
     }
 
     /// Children list is empty
@@ -192,8 +185,7 @@ where
     pub fn iter(&self) -> impl Iterator<Item = T> + '_ {
         // clone each child lazily.
         // This way `self.iter().next()` only has to clone a single node.
-        // TODO not sure if I shouldnt keep the Rc here
-        self.children.iter().map(RcExt::unwrap_or_clone)
+        self.children.iter().cloned()
     }
 
     /// Convert the children elements to another object (if there are any).
@@ -205,7 +197,7 @@ where
     /// children.map(|children| {
     ///     html! {
     ///         <div class={classes!("container")}>
-    ///             {children}
+    ///             {children.clone()}
     ///         </div>
     ///     }
     /// })
@@ -218,63 +210,37 @@ where
             closure(self)
         }
     }
-
-    pub(crate) fn to_vec(&self) -> Vec<T> {
-        self.iter().collect()
-    }
 }
 
-impl<T: Clone> Default for ChildrenRenderer<T> {
+impl<T> Default for ChildrenRenderer<T> {
     fn default() -> Self {
         Self {
-            children: Default::default(),
+            children: Vec::new(),
         }
     }
 }
 
-impl<T: Clone> fmt::Debug for ChildrenRenderer<T> {
+impl<T> fmt::Debug for ChildrenRenderer<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str("ChildrenRenderer<_>")
     }
 }
 
-#[derive(Debug)]
-#[doc(hidden)]
-pub struct Iter<T: Clone + 'static> {
-    children: implicit_clone::unsync::Iter<Rc<T>>,
-}
-
-impl<T: Clone + 'static> Iterator for Iter<T> {
-    type Item = T;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.children.next().map(|x| RcExt::unwrap_or_clone(x))
-    }
-}
-
-impl<T: ImplicitClone> IntoIterator for ChildrenRenderer<T> {
-    type IntoIter = Iter<T>;
+impl<T> IntoIterator for ChildrenRenderer<T> {
+    type IntoIter = std::vec::IntoIter<Self::Item>;
     type Item = T;
 
     fn into_iter(self) -> Self::IntoIter {
-        Iter {
-            children: self.children.iter(),
-        }
-    }
-}
-
-impl<T: Clone> FromIterator<T> for ChildrenRenderer<T> {
-    fn from_iter<IT: IntoIterator<Item = T>>(it: IT) -> Self {
-        Self {
-            children: it.into_iter().map(Rc::new).collect(),
-        }
+        self.children.into_iter()
     }
 }
 
 impl From<ChildrenRenderer<Html>> for Html {
-    fn from(val: ChildrenRenderer<Html>) -> Self {
+    fn from(mut val: ChildrenRenderer<Html>) -> Self {
         if val.children.len() == 1 {
-            return RcExt::unwrap_or_clone(val.children[0].clone());
+            if let Some(m) = val.children.pop() {
+                return m;
+            }
         }
 
         Html::VList(Rc::new(val.into()))
@@ -286,7 +252,7 @@ impl From<ChildrenRenderer<Html>> for VList {
         if val.is_empty() {
             return VList::new();
         }
-        VList::with_children(val.to_vec(), None)
+        VList::with_children(val.children, None)
     }
 }
 
@@ -319,7 +285,7 @@ mod tests {
 
     #[test]
     fn children_map() {
-        let children = Children::new(Default::default());
+        let children = Children::new(vec![]);
         let res = children.map(|children| Some(children.clone()));
         assert!(res.is_none());
         let children = Children::new(vec![Default::default()]);
diff --git a/packages/yew/src/html/conversion/into_prop_value.rs b/packages/yew/src/html/conversion/into_prop_value.rs
@@ -86,47 +86,47 @@ where
 impl<T, C> IntoPropValue<ChildrenRenderer<C>> for VChild<T>
 where
     T: BaseComponent,
-    C: ImplicitClone + Into<VNode>,
+    C: Clone + Into<VNode>,
     VChild<T>: Into<C>,
 {
     #[inline]
     fn into_prop_value(self) -> ChildrenRenderer<C> {
-        [self.into()].into_iter().collect()
+        ChildrenRenderer::new(vec![self.into()])
     }
 }
 
 impl<T, C> IntoPropValue<Option<ChildrenRenderer<C>>> for VChild<T>
 where
     T: BaseComponent,
-    C: ImplicitClone + Into<VNode>,
+    C: Clone + Into<VNode>,
     VChild<T>: Into<C>,
 {
     #[inline]
     fn into_prop_value(self) -> Option<ChildrenRenderer<C>> {
-        Some([self.into()].into_iter().collect())
+        Some(ChildrenRenderer::new(vec![self.into()]))
     }
 }
 
 impl<T, C> IntoPropValue<Option<ChildrenRenderer<C>>> for Option<VChild<T>>
 where
     T: BaseComponent,
-    C: ImplicitClone + Into<VNode>,
+    C: Clone + Into<VNode>,
     VChild<T>: Into<C>,
 {
     #[inline]
     fn into_prop_value(self) -> Option<ChildrenRenderer<C>> {
-        self.map(|m| [m.into()].into_iter().collect())
+        self.map(|m| ChildrenRenderer::new(vec![m.into()]))
     }
 }
 
 impl<T, R> IntoPropValue<ChildrenRenderer<R>> for Vec<T>
 where
     T: Into<R>,
-    R: ImplicitClone + Into<VNode>,
+    R: Clone + Into<VNode>,
 {
     #[inline]
     fn into_prop_value(self) -> ChildrenRenderer<R> {
-        self.into_iter().map(|m| m.into()).collect()
+        ChildrenRenderer::new(self.into_iter().map(|m| m.into()).collect())
     }
 }
 
@@ -167,33 +167,24 @@ impl IntoPropValue<VNode> for ChildrenRenderer<VNode> {
     }
 }
 
-impl IntoPropValue<VNode> for &ChildrenRenderer<VNode> {
-    #[inline]
-    fn into_prop_value(self) -> VNode {
-        VNode::VList(Rc::new(self.clone().into()))
-    }
-}
-
 impl IntoPropValue<ChildrenRenderer<VNode>> for VNode {
     #[inline]
     fn into_prop_value(self) -> ChildrenRenderer<VNode> {
-        [self].into_iter().collect()
+        ChildrenRenderer::new(vec![self])
     }
 }
 
 impl IntoPropValue<ChildrenRenderer<VNode>> for VText {
     #[inline]
     fn into_prop_value(self) -> ChildrenRenderer<VNode> {
-        [self.into()].into_iter().collect()
+        ChildrenRenderer::new(vec![self.into()])
     }
 }
 
 impl IntoPropValue<VList> for ChildrenRenderer<VNode> {
     #[inline]
     fn into_prop_value(self) -> VList {
-        // TODO converting IArray to Vec doesn't seem optimal, but it's too complicated to change
-        //      VList for now
-        VList::with_children(self.to_vec(), None)
+        VList::with_children(self.children, None)
     }
 }
 
@@ -206,7 +197,7 @@ impl<C: BaseComponent> IntoPropValue<VList> for VChild<C> {
 
 impl IntoPropValue<ChildrenRenderer<VNode>> for AttrValue {
     fn into_prop_value(self) -> ChildrenRenderer<VNode> {
-        [VNode::VText(VText::new(self))].into_iter().collect()
+        ChildrenRenderer::new(vec![VNode::VText(VText::new(self))])
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -86,47 +86,47 @@ where`
`86`	`86`	`impl<T, C> IntoPropValue<ChildrenRenderer<C>> for VChild<T>`
`87`	`87`	`where`
`88`	`88`	`T: BaseComponent,`
`89`		`- C: ImplicitClone + Into<VNode>,`
	`89`	`+ C: Clone + Into<VNode>,`
`90`	`90`	`VChild<T>: Into<C>,`
`91`	`91`	`{`
`92`	`92`	`#[inline]`
`93`	`93`	`fn into_prop_value(self) -> ChildrenRenderer<C> {`
`94`		`- [self.into()].into_iter().collect()`
	`94`	`+ ChildrenRenderer::new(vec![self.into()])`
`95`	`95`	`}`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`impl<T, C> IntoPropValue<Option<ChildrenRenderer<C>>> for VChild<T>`
`99`	`99`	`where`
`100`	`100`	`T: BaseComponent,`
`101`		`- C: ImplicitClone + Into<VNode>,`
	`101`	`+ C: Clone + Into<VNode>,`
`102`	`102`	`VChild<T>: Into<C>,`
`103`	`103`	`{`
`104`	`104`	`#[inline]`
`105`	`105`	`fn into_prop_value(self) -> Option<ChildrenRenderer<C>> {`
`106`		`- Some([self.into()].into_iter().collect())`
	`106`	`+ Some(ChildrenRenderer::new(vec![self.into()]))`
`107`	`107`	`}`
`108`	`108`	`}`
`109`	`109`
`110`	`110`	`impl<T, C> IntoPropValue<Option<ChildrenRenderer<C>>> for Option<VChild<T>>`
`111`	`111`	`where`
`112`	`112`	`T: BaseComponent,`
`113`		`- C: ImplicitClone + Into<VNode>,`
	`113`	`+ C: Clone + Into<VNode>,`
`114`	`114`	`VChild<T>: Into<C>,`
`115`	`115`	`{`
`116`	`116`	`#[inline]`
`117`	`117`	`fn into_prop_value(self) -> Option<ChildrenRenderer<C>> {`
`118`		`- self.map(\|m\| [m.into()].into_iter().collect())`
	`118`	`+ self.map(\|m\| ChildrenRenderer::new(vec![m.into()]))`
`119`	`119`	`}`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`impl<T, R> IntoPropValue<ChildrenRenderer<R>> for Vec<T>`
`123`	`123`	`where`
`124`	`124`	`T: Into<R>,`
`125`		`- R: ImplicitClone + Into<VNode>,`
	`125`	`+ R: Clone + Into<VNode>,`
`126`	`126`	`{`
`127`	`127`	`#[inline]`
`128`	`128`	`fn into_prop_value(self) -> ChildrenRenderer<R> {`
`129`		`- self.into_iter().map(\|m\| m.into()).collect()`
	`129`	`+ ChildrenRenderer::new(self.into_iter().map(\|m\| m.into()).collect())`
`130`	`130`	`}`
`131`	`131`	`}`
`132`	`132`
`@@ -167,33 +167,24 @@ impl IntoPropValue<VNode> for ChildrenRenderer<VNode> {`
`167`	`167`	`}`
`168`	`168`	`}`
`169`	`169`
`170`		`-impl IntoPropValue<VNode> for &ChildrenRenderer<VNode> {`
`171`		`- #[inline]`
`172`		`- fn into_prop_value(self) -> VNode {`
`173`		`- VNode::VList(Rc::new(self.clone().into()))`
`174`		`- }`
`175`		`-}`
`176`		`-`
`177`	`170`	`impl IntoPropValue<ChildrenRenderer<VNode>> for VNode {`
`178`	`171`	`#[inline]`
`179`	`172`	`fn into_prop_value(self) -> ChildrenRenderer<VNode> {`
`180`		`- [self].into_iter().collect()`
	`173`	`+ ChildrenRenderer::new(vec![self])`
`181`	`174`	`}`
`182`	`175`	`}`
`183`	`176`
`184`	`177`	`impl IntoPropValue<ChildrenRenderer<VNode>> for VText {`
`185`	`178`	`#[inline]`
`186`	`179`	`fn into_prop_value(self) -> ChildrenRenderer<VNode> {`
`187`		`- [self.into()].into_iter().collect()`
	`180`	`+ ChildrenRenderer::new(vec![self.into()])`
`188`	`181`	`}`
`189`	`182`	`}`
`190`	`183`
`191`	`184`	`impl IntoPropValue<VList> for ChildrenRenderer<VNode> {`
`192`	`185`	`#[inline]`
`193`	`186`	`fn into_prop_value(self) -> VList {`
`194`		`- // TODO converting IArray to Vec doesn't seem optimal, but it's too complicated to change`
`195`		`- // VList for now`
`196`		`- VList::with_children(self.to_vec(), None)`
	`187`	`+ VList::with_children(self.children, None)`
`197`	`188`	`}`
`198`	`189`	`}`
`199`	`190`
`@@ -206,7 +197,7 @@ impl<C: BaseComponent> IntoPropValue<VList> for VChild<C> {`
`206`	`197`
`207`	`198`	`impl IntoPropValue<ChildrenRenderer<VNode>> for AttrValue {`
`208`	`199`	`fn into_prop_value(self) -> ChildrenRenderer<VNode> {`
`209`		`- [VNode::VText(VText::new(self))].into_iter().collect()`
	`200`	`+ ChildrenRenderer::new(vec![VNode::VText(VText::new(self))])`
`210`	`201`	`}`
`211`	`202`	`}`
`212`	`203`