Fix call stack exceeded bug (#1624)

* Fix call stack exceeded bug

* Fix borrow error

* Update scope node_ref copy when component updates

yew/src/html/mod.rs

@@ -455,6 +455,19 @@ impl NodeRef {
         this.node = None;
         this.link = Some(node_ref);
     }
+
+    /// Reuse an existing `NodeRef`
+    pub(crate) fn reuse(&self, node_ref: Self) {
+        // Avoid circular references
+        if self == &node_ref {
+            return;
+        }
+
+        let mut this = self.0.borrow_mut();
+        let existing = node_ref.0.borrow();
+        this.node = existing.node.clone();
+        this.link = existing.link.clone();
+    }
 }
 
 /// Trait for rendering virtual DOM elements

yew/src/html/scope.rs

@@ -23,8 +23,8 @@ pub(crate) enum ComponentUpdate<COMP: Component> {
     Message(COMP::Message),
     /// Wraps batch of messages for a component.
     MessageBatch(Vec<COMP::Message>),
-    /// Wraps properties and next sibling for a component.
-    Properties(COMP::Properties, NodeRef),
+    /// Wraps properties, node ref, and next sibling for a component.
+    Properties(COMP::Properties, NodeRef, NodeRef),
 }
 
 /// Untyped scope used for accessing parent scope
@@ -391,7 +391,9 @@ where
                 ComponentUpdate::MessageBatch(messages) => messages
                     .into_iter()
                     .fold(false, |acc, msg| state.component.update(msg) || acc),
-                ComponentUpdate::Properties(props, next_sibling) => {
+                ComponentUpdate::Properties(props, node_ref, next_sibling) => {
+                    // When components are updated, a new node ref could have been passed in
+                    state.node_ref = node_ref;
                     // When components are updated, their siblings were likely also updated
                     state.next_sibling = next_sibling;
                     state.component.change(props)

yew/src/virtual_dom/vcomp.rs

@@ -122,7 +122,7 @@ trait Mountable {
         parent: Element,
         next_sibling: NodeRef,
     ) -> Box<dyn Scoped>;
-    fn reuse(self: Box<Self>, scope: &dyn Scoped, next_sibling: NodeRef);
+    fn reuse(self: Box<Self>, node_ref: NodeRef, scope: &dyn Scoped, next_sibling: NodeRef);
 }
 
 struct PropsWrapper<COMP: Component> {
@@ -162,9 +162,13 @@ impl<COMP: Component> Mountable for PropsWrapper<COMP> {
         Box::new(scope)
     }
 
-    fn reuse(self: Box<Self>, scope: &dyn Scoped, next_sibling: NodeRef) {
+    fn reuse(self: Box<Self>, node_ref: NodeRef, scope: &dyn Scoped, next_sibling: NodeRef) {
         let scope: Scope<COMP> = scope.to_any().downcast();
-        scope.update(ComponentUpdate::Properties(self.props, next_sibling));
+        scope.update(ComponentUpdate::Properties(
+            self.props,
+            node_ref,
+            next_sibling,
+        ));
     }
 }
 
@@ -186,9 +190,9 @@ impl VDiff for VComp {
             if let VNode::VComp(ref mut vcomp) = &mut ancestor {
                 // If the ancestor is the same type, reuse it and update its properties
                 if self.type_id == vcomp.type_id && self.key == vcomp.key {
-                    self.node_ref.link(vcomp.node_ref.clone());
+                    self.node_ref.reuse(vcomp.node_ref.clone());
                     let scope = vcomp.scope.take().expect("VComp is not mounted");
-                    mountable.reuse(scope.borrow(), next_sibling);
+                    mountable.reuse(self.node_ref.clone(), scope.borrow(), next_sibling);
                     self.scope = Some(scope);
                     return vcomp.node_ref.clone();
                 }
@@ -311,14 +315,35 @@ mod tests {
         }
 
         fn change(&mut self, _: Self::Properties) -> ShouldRender {
-            unimplemented!();
+            true
         }
 
         fn view(&self) -> Html {
             unimplemented!();
         }
     }
 
+    #[test]
+    fn update_loop() {
+        let document = crate::utils::document();
+        let parent_scope: AnyScope = crate::html::Scope::<Comp>::new(None).into();
+        let parent_element = document.create_element("div").unwrap();
+
+        let mut ancestor = html! { <Comp></Comp> };
+        ancestor.apply(&parent_scope, &parent_element, NodeRef::default(), None);
+
+        for _ in 0..10000 {
+            let mut node = html! { <Comp></Comp> };
+            node.apply(
+                &parent_scope,
+                &parent_element,
+                NodeRef::default(),
+                Some(ancestor),
+            );
+            ancestor = node;
+        }
+    }
+
     #[test]
     fn set_properties_to_component() {
         html! {