Use IS_REACT_ACT_ENVIRONMENT to disable warnings

If `IS_REACT_ACT_ENVIRONMENT` is set to `false`, we will suppress
any `act` warnings. Otherwise, the behavior of `act` is the same as in
React 17: if `jest` is defined, it warns.

In concurrent mode, the plan is to remove the `jest` check and only warn
if `IS_REACT_ACT_ENVIRONMENT` is true. I have not implemented that
part yet.

Author: acdlite

.eslintrc.js

@@ -279,5 +279,6 @@ module.exports = {
     __VARIANT__: true,
     gate: true,
     trustedTypes: true,
+    IS_REACT_ACT_ENVIRONMENT: true,
   },
 };

packages/jest-react/src/internalAct.js

@@ -18,9 +18,7 @@ import type {Thenable} from 'shared/ReactTypes';
 
 import * as Scheduler from 'scheduler/unstable_mock';
 
-import ReactSharedInternals from 'shared/ReactSharedInternals';
 import enqueueTask from 'shared/enqueueTask';
-const {ReactCurrentActQueue} = ReactSharedInternals;
 
 let actingUpdatesScopeDepth = 0;
 
@@ -37,15 +35,18 @@ export function act(scope: () => Thenable<mixed> | void) {
     );
   }
 
+  const previousIsActEnvironment = global.IS_REACT_ACT_ENVIRONMENT;
   const previousActingUpdatesScopeDepth = actingUpdatesScopeDepth;
   actingUpdatesScopeDepth++;
   if (__DEV__ && actingUpdatesScopeDepth === 1) {
-    ReactCurrentActQueue.disableActWarning = true;
+    // Because this is not the "real" `act`, we set this to `false` so React
+    // knows not to fire `act` warnings.
+    global.IS_REACT_ACT_ENVIRONMENT = false;
   }
 
   const unwind = () => {
     if (__DEV__ && actingUpdatesScopeDepth === 1) {
-      ReactCurrentActQueue.disableActWarning = false;
+      global.IS_REACT_ACT_ENVIRONMENT = previousIsActEnvironment;
     }
     actingUpdatesScopeDepth--;
 

packages/react-dom/src/__tests__/ReactTestUtilsAct-test.js

@@ -273,6 +273,40 @@ function runActTests(label, render, unmount, rerender) {
         ]);
       });
 
+      // @gate __DEV__
+      it('does not warn if IS_REACT_ACT_ENVIRONMENT is set to false', () => {
+        let setState;
+        function App() {
+          const [state, _setState] = React.useState(0);
+          setState = _setState;
+          return state;
+        }
+
+        act(() => {
+          render(<App />, container);
+        });
+
+        // First show that it does warn
+        expect(() => setState(1)).toErrorDev(
+          'An update to App inside a test was not wrapped in act(...)',
+        );
+
+        // Now do the same thing again, but disable with the environment flag
+        const prevIsActEnvironment = process.env.IS_REACT_ACT_ENVIRONMENT;
+        global.IS_REACT_ACT_ENVIRONMENT = false;
+        try {
+          setState(2);
+        } finally {
+          global.IS_REACT_ACT_ENVIRONMENT = prevIsActEnvironment;
+        }
+
+        // When the flag is restored to its previous value, it should start
+        // warning again. This shows that React reads the flag each time.
+        expect(() => setState(3)).toErrorDev(
+          'An update to App inside a test was not wrapped in act(...)',
+        );
+      });
+
       describe('fake timers', () => {
         beforeEach(() => {
           jest.useFakeTimers();

packages/react-reconciler/src/ReactFiberAct.new.js

@@ -10,13 +10,23 @@
 import type {Fiber} from './ReactFiber.new';
 import {warnsIfNotActing} from './ReactFiberHostConfig';
 
-import ReactSharedInternals from 'shared/ReactSharedInternals';
-
-const {ReactCurrentActQueue} = ReactSharedInternals;
-
 export function isActEnvironment(fiber: Fiber) {
-  const disableActWarning = ReactCurrentActQueue.disableActWarning;
+  const isReactActEnvironmentGlobal =
+    // $FlowExpectedError – Flow doesn't know about IS_REACT_ACT_ENVIRONMENT global
+    typeof IS_REACT_ACT_ENVIRONMENT !== 'undefined'
+      ? IS_REACT_ACT_ENVIRONMENT
+      : undefined;
+
+  // TODO: Only check `jest` in legacy mode. In concurrent mode, this heuristic
+  // is repalced by IS_REACT_ACT_ENVIRONMENT.
   // $FlowExpectedError - Flow doesn't know about jest
   const jestIsDefined = typeof jest !== 'undefined';
-  return warnsIfNotActing && jestIsDefined && !disableActWarning;
+  return (
+    warnsIfNotActing &&
+    jestIsDefined &&
+    // Legacy mode assumes an act environment whenever `jest` is defined, but
+    // you can still turn off spurious warnings by setting
+    // IS_REACT_ACT_ENVIRONMENT explicitly to false.
+    isReactActEnvironmentGlobal !== false
+  );
 }

packages/react-reconciler/src/ReactFiberAct.old.js

@@ -10,13 +10,23 @@
 import type {Fiber} from './ReactFiber.old';
 import {warnsIfNotActing} from './ReactFiberHostConfig';
 
-import ReactSharedInternals from 'shared/ReactSharedInternals';
-
-const {ReactCurrentActQueue} = ReactSharedInternals;
-
 export function isActEnvironment(fiber: Fiber) {
-  const disableActWarning = ReactCurrentActQueue.disableActWarning;
+  const isReactActEnvironmentGlobal =
+    // $FlowExpectedError – Flow doesn't know about IS_REACT_ACT_ENVIRONMENT global
+    typeof IS_REACT_ACT_ENVIRONMENT !== 'undefined'
+      ? IS_REACT_ACT_ENVIRONMENT
+      : undefined;
+
+  // TODO: Only check `jest` in legacy mode. In concurrent mode, this heuristic
+  // is repalced by IS_REACT_ACT_ENVIRONMENT.
   // $FlowExpectedError - Flow doesn't know about jest
   const jestIsDefined = typeof jest !== 'undefined';
-  return warnsIfNotActing && jestIsDefined && !disableActWarning;
+  return (
+    warnsIfNotActing &&
+    jestIsDefined &&
+    // Legacy mode assumes an act environment whenever `jest` is defined, but
+    // you can still turn off spurious warnings by setting
+    // IS_REACT_ACT_ENVIRONMENT explicitly to false.
+    isReactActEnvironmentGlobal !== false
+  );
 }

packages/react/src/ReactCurrentActQueue.js

@@ -11,12 +11,6 @@ type RendererTask = boolean => RendererTask | null;
 
 const ReactCurrentActQueue = {
   current: (null: null | Array<RendererTask>),
-  // Our internal tests use a custom implementation of `act` that works by
-  // mocking the Scheduler package. Use this field to disable the `act` warning.
-  // TODO: Maybe the warning should be disabled by default, and then turned
-  // on at the testing frameworks layer? Instead of what we do now, which
-  // is check if a `jest` global is defined.
-  disableActWarning: (false: boolean),
 
   // Used to reproduce behavior of `batchedUpdates` in legacy mode.
   isBatchingLegacy: false,

scripts/rollup/validate/eslintrc.cjs.js

@@ -42,6 +42,9 @@ module.exports = {
     // jest
     expect: true,
     jest: true,
+
+    // act
+    IS_REACT_ACT_ENVIRONMENT: true,
   },
   parserOptions: {
     ecmaVersion: 5,

scripts/rollup/validate/eslintrc.cjs2015.js

@@ -42,6 +42,9 @@ module.exports = {
     // jest
     expect: true,
     jest: true,
+
+    // act
+    IS_REACT_ACT_ENVIRONMENT: true,
   },
   parserOptions: {
     ecmaVersion: 2015,

scripts/rollup/validate/eslintrc.esm.js

@@ -42,6 +42,9 @@ module.exports = {
     // jest
     expect: true,
     jest: true,
+
+    // act
+    IS_REACT_ACT_ENVIRONMENT: true,
   },
   parserOptions: {
     ecmaVersion: 2017,

scripts/rollup/validate/eslintrc.fb.js

@@ -38,6 +38,9 @@ module.exports = {
 
     // jest
     jest: true,
+
+    // act
+    IS_REACT_ACT_ENVIRONMENT: true,
   },
   parserOptions: {
     ecmaVersion: 5,