You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Basically what happens is that when we encounter a fragment we unwrap it to return is children, this way when elements get wrapped with fragments we don't risk losing state in between renders.
This has a consequence when it is used in hooks environments as a hook with a closure will capture the outer scope. As can be seen in the reproduction, if an effect (or any other hook) closure takes a snapshot of the outer closure it will take the Fragment we unwrap into memory, this means that during diff we'll effectively start mutating its children. Note that it's important that the hook has no dependencies for this to be reproduced.
Every time we re-render we'll take a new snapshot of the closure which retains a copy of Fragment with pointers to all of its populated children. We unwrap the Fragment which still points at its children which point back at the parent of the Fragment. The closure points at the Fragment, the Fragment points at its children (props.children) and the children point at the parent component of Fragment.
With the implemented measure we clear props.children of the Fragment so that we effectively break this chain of pointers and allow the Fragment to be gc'd in-between renders caused by updates to the same component.
Fun fact, when we implement #4679's reproduction with class components there is no memory leak, this was one of the first pointers to me that hooks and their closures were the culprit.
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Fixes #4679
Basically what happens is that when we encounter a fragment we unwrap it to return is children, this way when elements get wrapped with fragments we don't risk losing state in between renders.
This has a consequence when it is used in hooks environments as a hook with a closure will capture the outer scope. As can be seen in the reproduction, if an effect (or any other hook) closure takes a snapshot of the outer closure it will take the
Fragment
we unwrap into memory, this means that during diff we'll effectively start mutating its children. Note that it's important that the hook has no dependencies for this to be reproduced.Every time we re-render we'll take a new snapshot of the closure which retains a copy of
Fragment
with pointers to all of its populated children. We unwrap the Fragment which still points at its children which point back at theparent
of theFragment
. The closure points at the Fragment, the Fragment points at its children (props.children) and the children point at the parent component of Fragment.With the implemented measure we clear
props.children
of theFragment
so that we effectively break this chain of pointers and allow theFragment
to be gc'd in-between renders caused by updates to the same component.Fun fact, when we implement #4679's reproduction with class components there is no memory leak, this was one of the first pointers to me that hooks and their closures were the culprit.