Update on "[compiler] Validate against locals being reassigned after render"

Adds a pass which validates that local variables are not reassigned by functions which may be called after render. This is a straightforward forward data-flow analysis, where we:
1. Build up a mapping of context variables in the outer component/hook
2. Find ObjectMethod/FunctionExpressions which may reassign those context variables
3. Propagate aliases of those functions via StoreLocal/LoadLocal
4. Disallow passing those functions with a Freeze effect. This includes JSX arguments, hook arguments, hook return types, etc.

Conceptually, a function that reassigns a local is inherently mutable. Frozen functions must be side-effect free, so these two categories are incompatible and we can use the freeze effect to find all instances of where such functions are disallowed rather than special-casing eg hook calls and JSX.

[ghstack-poisoned]

Author: josephsavona

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateLocalsNotReassignedAfterRender.ts

@@ -5,20 +5,12 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import prettyFormat from "pretty-format";
 import { CompilerError, Effect } from "..";
-import {
-  HIRFunction,
-  IdentifierId,
-  Place,
-  getHookKind,
-  isUseOperator,
-} from "../HIR";
+import { HIRFunction, IdentifierId, Place } from "../HIR";
 import {
   eachInstructionValueOperand,
   eachTerminalOperand,
 } from "../HIR/visitors";
-import { isEffectHook } from "./ValidateMemoizedEffectDependencies";
 
 /**
  * Validates that local variables cannot be reassigned after render.
@@ -111,8 +103,10 @@ function getContextReassignment(
               return value.lvalue.place;
             }
           } else {
-            // We only track reassignments of variables defined in the outer
-            // component or hook.
+            /*
+             * We only track reassignments of variables defined in the outer
+             * component or hook.
+             */
             contextVariables.add(value.lvalue.place.identifier.id);
           }
           break;
@@ -130,8 +124,10 @@ function getContextReassignment(
               reassignment !== undefined &&
               operand.effect === Effect.Freeze
             ) {
-              // Functions that reassign local variables are inherently mutable and are unsafe to pass
-              // to a place that expects a frozen value. Propagate the reassignment upward.
+              /*
+               * Functions that reassign local variables are inherently mutable and are unsafe to pass
+               * to a place that expects a frozen value. Propagate the reassignment upward.
+               */
               return reassignment;
             }
           }