useMutableSource() enables React components to safely and efficiently read from a mutable external source in Concurrent Mode. The API will detect mutations that occur during a render to avoid tearing and it will automatically schedule updates when the source is mutated.

RFC: reactjs/rfcs#147

This commit changes useMutableSource to use an update queue by composing useEffect and useState internally. This ended up being a little bigger than I would have expected due to the need to create mount, update, and rerender implementations, but that's probably okay for now.

This commit also makes a few orthogonal changes as the result of discussions with Relay, Redux, etc:
1. Snapshots are eagerly evaluated so components can bailout early even when 'scoped subscriptions' are not possible.
2. The subscribe callback function now expects to be passed the updated snapshot value.

…ot value

This is being done to reduce how frequently we potentially deopt during render.

I also tidied up the useMutableSource mount/update/rerender implementations to reduce their overall file size.

A selector might throw after a source mutation. e.g. it might try to read from a part of the store that no longer exists. In this case we should still schedule an update with React. Worst case the selector will throw again and then an error boundary will handle it.

getSnapshot should be memoized to only change when its inputs change, but if that memoization is done incorrectly (or if the new snapshot just happens to be the same regardless of a changed dependency) then we can avoid deopting to a root re-render.

Rather than passing them in explicitly. This removes the extra function call.

Remove unnecessary useRef in favor of hook state.

Directly mutate composed state hook queue to reset in the case of a new subscribe or source.

…ypoints

This prevents the subscription callback from closing over stale values.

Even if the current snapshot value is the same, there may be pending, lower priority updates that we no longer want to eventually render.

I initially thought that we could treat them as safe if the returned snapshot value was the same, but this ignored the case where the underlying source was mutated between when the state update was scheduled and when the component later rendered with a new getSnapshot function. (This commit includes a test that failed without this fix.)

1. Reset mutable source WIP version in complete and unwind work (rather than prepare fresh stack).
2. Add check to warn about multiple primary/secondary renderers using the same mutable source. (Patterned after our current context warning.)
3. Changed the way I'm calculating expiration time for mutated sources to use computeExpirationForFiber().
4. Changed undefined unsubscribe function from invariant to warning.
5. Replaced !== checks with Object.is() checks to be more consistent with precedent.
6. Added a couple of new warning tests. (One of them has a pending TODO.)

…table release

1. Use currentlyRenderingFiber to calculate expiration time rather than using a ref.
2. Use polyfilled is() rather than Object.is()
3. Add __EXPERIMENTAL__ guard to test since new APIs aren't in stable build
4. Removed error code that was changed to warning.

If a mutation happens between the first and second renderer to use a source, we need to explicitly reset the source before restarting the second renderer.

I am being a little lazy here and merging instead of rebasing because practically every commit conflicted with Dominic's recent useEvent PR. If anyone feel strongly about this, I will revert the commit and rebase. Since the commit will be squashes away during the merge though, I don't think it matters much at this point.