babel-plugin-react-compiler 0.0.0-experimental-de2cfda-20240912 → 0.0.0-experimental-23b8160-20240916

package/dist/index.js

@@ -162090,6 +162090,248 @@ let Visitor$8 = class Visitor extends ReactiveFunctionTransform {
     return {kind: 'keep'};
   }
 };
+function inferOperandEffect(state, place) {
+  const value = state.kind(place);
+  CompilerError.invariant(value != null, {
+    reason: 'Expected operand to have a kind',
+    loc: null,
+  });
+  switch (place.effect) {
+    case exports.Effect.Store:
+    case exports.Effect.Mutate: {
+      if (isRefOrRefValue(place.identifier)) {
+        break;
+      } else if (value.kind === exports.ValueKind.Context) {
+        return {
+          kind: 'ContextMutation',
+          loc: place.loc,
+          effect: place.effect,
+          places: value.context.size === 0 ? new Set([place]) : value.context,
+        };
+      } else if (
+        value.kind !== exports.ValueKind.Mutable &&
+        value.kind !== exports.ValueKind.Primitive
+      ) {
+        let reason = getWriteErrorReason(value);
+        return {
+          kind:
+            value.reason.size === 1 && value.reason.has(ValueReason.Global)
+              ? 'GlobalMutation'
+              : 'ReactMutation',
+          error: {
+            reason: reason,
+            description:
+              place.identifier.name !== null &&
+              place.identifier.name.kind === 'named'
+                ? `Found mutation of \`${place.identifier.name.value}\``
+                : null,
+            loc: place.loc,
+            suggestions: null,
+            severity: exports.ErrorSeverity.InvalidReact,
+          },
+        };
+      }
+      break;
+    }
+  }
+  return null;
+}
+function inheritFunctionEffects(state, place) {
+  const effects = inferFunctionInstrEffects(state, place);
+  return effects
+    .flatMap(effect => {
+      if (effect.kind === 'GlobalMutation' || effect.kind === 'ReactMutation') {
+        return [effect];
+      } else {
+        const effects = [];
+        CompilerError.invariant(effect.kind === 'ContextMutation', {
+          reason: 'Expected ContextMutation',
+          loc: null,
+        });
+        for (const place of effect.places) {
+          if (state.isDefined(place)) {
+            const replayedEffect = inferOperandEffect(
+              state,
+              Object.assign(Object.assign({}, place), {
+                loc: effect.loc,
+                effect: effect.effect,
+              })
+            );
+            if (replayedEffect != null) {
+              if (replayedEffect.kind === 'ContextMutation') {
+                effects.push(effect);
+              } else {
+                effects.push(replayedEffect);
+              }
+            }
+          }
+        }
+        return effects;
+      }
+    })
+    .filter(effect => effect != null);
+}
+function inferFunctionInstrEffects(state, place) {
+  const effects = [];
+  const instrs = state.values(place);
+  CompilerError.invariant(instrs != null, {
+    reason: 'Expected operand to have instructions',
+    loc: null,
+  });
+  for (const instr of instrs) {
+    if (
+      (instr.kind === 'FunctionExpression' || instr.kind === 'ObjectMethod') &&
+      instr.loweredFunc.func.effects != null
+    ) {
+      effects.push(...instr.loweredFunc.func.effects);
+    }
+  }
+  return effects;
+}
+function operandEffects(state, place, filterRenderSafe) {
+  const functionEffects = [];
+  const effect = inferOperandEffect(state, place);
+  effect && functionEffects.push(effect);
+  functionEffects.push(...inheritFunctionEffects(state, place));
+  if (filterRenderSafe) {
+    return functionEffects.filter(effect => !isEffectSafeOutsideRender(effect));
+  } else {
+    return functionEffects;
+  }
+}
+function inferInstructionFunctionEffects(env, state, instr) {
+  var _a, _b;
+  var _c;
+  const functionEffects = [];
+  switch (instr.value.kind) {
+    case 'JsxExpression': {
+      if (instr.value.tag.kind === 'Identifier') {
+        functionEffects.push(...operandEffects(state, instr.value.tag, false));
+      }
+      (_a = instr.value.children) === null || _a === void 0
+        ? void 0
+        : _a.forEach(child =>
+            functionEffects.push(...operandEffects(state, child, false))
+          );
+      for (const attr of instr.value.props) {
+        if (attr.kind === 'JsxSpreadAttribute') {
+          functionEffects.push(...operandEffects(state, attr.argument, false));
+        } else {
+          functionEffects.push(...operandEffects(state, attr.place, true));
+        }
+      }
+      break;
+    }
+    case 'ObjectMethod':
+    case 'FunctionExpression': {
+      for (const operand of eachInstructionOperand(instr)) {
+        (_b = (_c = instr.value.loweredFunc.func).effects) !== null &&
+        _b !== void 0
+          ? _b
+          : (_c.effects = []);
+        instr.value.loweredFunc.func.effects.push(
+          ...inferFunctionInstrEffects(state, operand)
+        );
+      }
+      break;
+    }
+    case 'MethodCall':
+    case 'CallExpression': {
+      let callee;
+      if (instr.value.kind === 'MethodCall') {
+        callee = instr.value.property;
+        functionEffects.push(
+          ...operandEffects(state, instr.value.receiver, false)
+        );
+      } else {
+        callee = instr.value.callee;
+      }
+      functionEffects.push(...operandEffects(state, callee, false));
+      let isHook = getHookKind(env, callee.identifier) != null;
+      for (const arg of instr.value.args) {
+        const place = arg.kind === 'Identifier' ? arg : arg.place;
+        functionEffects.push(...operandEffects(state, place, isHook));
+      }
+      break;
+    }
+    case 'StartMemoize':
+    case 'FinishMemoize':
+    case 'LoadLocal':
+    case 'StoreLocal': {
+      break;
+    }
+    case 'StoreGlobal': {
+      functionEffects.push({
+        kind: 'GlobalMutation',
+        error: {
+          reason:
+            'Unexpected reassignment of a variable which was defined outside of the component. Components and hooks should be pure and side-effect free, but variable reassignment is a form of side-effect. If this variable is used in rendering, use useState instead. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#side-effects-must-run-outside-of-render)',
+          loc: instr.loc,
+          suggestions: null,
+          severity: exports.ErrorSeverity.InvalidReact,
+        },
+      });
+      break;
+    }
+    default: {
+      for (const operand of eachInstructionOperand(instr)) {
+        functionEffects.push(...operandEffects(state, operand, false));
+      }
+    }
+  }
+  return functionEffects;
+}
+function inferTerminalFunctionEffects(state, block) {
+  const functionEffects = [];
+  for (const operand of eachTerminalOperand(block.terminal)) {
+    functionEffects.push(...operandEffects(state, operand, true));
+  }
+  return functionEffects;
+}
+function raiseFunctionEffectErrors(functionEffects) {
+  functionEffects.forEach(eff => {
+    switch (eff.kind) {
+      case 'ReactMutation':
+      case 'GlobalMutation': {
+        CompilerError.throw(eff.error);
+      }
+      case 'ContextMutation': {
+        CompilerError.throw({
+          severity: exports.ErrorSeverity.Invariant,
+          reason: `Unexpected ContextMutation in top-level function effects`,
+          loc: eff.loc,
+        });
+      }
+      default:
+        assertExhaustive(
+          eff,
+          `Unexpected function effect kind \`${eff.kind}\``
+        );
+    }
+  });
+}
+function isEffectSafeOutsideRender(effect) {
+  return effect.kind === 'GlobalMutation';
+}
+function getWriteErrorReason(abstractValue) {
+  if (abstractValue.reason.has(ValueReason.Global)) {
+    return 'Writing to a variable defined outside a component or hook is not allowed. Consider using an effect';
+  } else if (abstractValue.reason.has(ValueReason.JsxCaptured)) {
+    return 'Updating a value used previously in JSX is not allowed. Consider moving the mutation before the JSX';
+  } else if (abstractValue.reason.has(ValueReason.Context)) {
+    return `Mutating a value returned from 'useContext()', which should not be mutated`;
+  } else if (abstractValue.reason.has(ValueReason.KnownReturnSignature)) {
+    return 'Mutating a value returned from a function whose return value should not be mutated';
+  } else if (abstractValue.reason.has(ValueReason.ReactiveFunctionArgument)) {
+    return 'Mutating component props or hook arguments is not allowed. Consider using a local variable instead';
+  } else if (abstractValue.reason.has(ValueReason.State)) {
+    return "Mutating a value returned from 'useState()', which should not be mutated. Use the setter function to update instead";
+  } else if (abstractValue.reason.has(ValueReason.ReducerState)) {
+    return "Mutating a value returned from 'useReducer()', which should not be mutated. Use the dispatch function to update instead";
+  } else {
+    return 'This mutates a variable that React considers immutable';
+  }
+}
 var _InferenceState_env, _InferenceState_values, _InferenceState_variables;
 const UndefinedValue = {
   kind: 'Primitive',
@@ -162189,35 +162431,16 @@ function inferReferenceEffects(fn, options = {isFunctionExpression: false}) {
       }
       statesByBlock.set(blockId, incomingState);
       const state = incomingState.clone();
-      inferBlock(fn.env, functionEffects, state, block);
+      inferBlock(fn.env, state, block, functionEffects);
       for (const nextBlockId of eachTerminalSuccessor(block.terminal)) {
         queue(nextBlockId, state);
       }
     }
   }
-  if (!options.isFunctionExpression) {
-    functionEffects.forEach(eff => {
-      switch (eff.kind) {
-        case 'ReactMutation':
-        case 'GlobalMutation': {
-          CompilerError.throw(eff.error);
-        }
-        case 'ContextMutation': {
-          CompilerError.throw({
-            severity: exports.ErrorSeverity.Invariant,
-            reason: `Unexpected ContextMutation in top-level function effects`,
-            loc: eff.loc,
-          });
-        }
-        default:
-          assertExhaustive(
-            eff,
-            `Unexpected function effect kind \`${eff.kind}\``
-          );
-      }
-    });
-  } else {
+  if (options.isFunctionExpression) {
     fn.effects = functionEffects;
+  } else {
+    raiseFunctionEffectErrors(functionEffects);
   }
 }
 class InferenceState {
@@ -162323,7 +162546,7 @@ class InferenceState {
       place.identifier.id
     );
   }
-  referenceAndRecordEffects(place, effectKind, reason, functionEffects) {
+  referenceAndRecordEffects(freezeActions, place, effectKind, reason) {
     const values = __classPrivateFieldGet(
       this,
       _InferenceState_variables,
@@ -162342,43 +162565,8 @@ class InferenceState {
           : exports.Effect.Read;
       return;
     }
-    for (const value of values) {
-      if (
-        (value.kind === 'FunctionExpression' ||
-          value.kind === 'ObjectMethod') &&
-        value.loweredFunc.func.effects != null
-      ) {
-        for (const effect of value.loweredFunc.func.effects) {
-          if (
-            effect.kind === 'GlobalMutation' ||
-            effect.kind === 'ReactMutation'
-          ) {
-            functionEffects.push(effect);
-          } else {
-            for (const place of effect.places) {
-              if (this.isDefined(place)) {
-                const replayedEffect = this.reference(
-                  Object.assign(Object.assign({}, place), {loc: effect.loc}),
-                  effect.effect,
-                  reason
-                );
-                if (replayedEffect != null) {
-                  if (replayedEffect.kind === 'ContextMutation') {
-                    functionEffects.push(effect);
-                  } else {
-                    functionEffects.push(replayedEffect);
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-    const functionEffect = this.reference(place, effectKind, reason);
-    if (functionEffect !== null) {
-      functionEffects.push(functionEffect);
-    }
+    const action = this.reference(place, effectKind, reason);
+    action && freezeActions.push(action);
   }
   freezeValues(values, reason) {
     for (const value of values) {
@@ -162424,7 +162612,7 @@ class InferenceState {
     });
     let valueKind = this.kind(place);
     let effect = null;
-    let functionEffect = null;
+    let freeze = null;
     switch (effectKind) {
       case exports.Effect.Freeze: {
         if (
@@ -162439,7 +162627,7 @@ class InferenceState {
             reason: reasonSet,
             context: new Set(),
           };
-          this.freezeValues(values, reasonSet);
+          freeze = {values: values, reason: reasonSet};
         } else {
           effect = exports.Effect.Read;
         }
@@ -162457,80 +162645,10 @@ class InferenceState {
         break;
       }
       case exports.Effect.Mutate: {
-        if (isRefOrRefValue(place.identifier));
-        else if (valueKind.kind === exports.ValueKind.Context) {
-          functionEffect = {
-            kind: 'ContextMutation',
-            loc: place.loc,
-            effect: effectKind,
-            places:
-              valueKind.context.size === 0
-                ? new Set([place])
-                : valueKind.context,
-          };
-        } else if (
-          valueKind.kind !== exports.ValueKind.Mutable &&
-          valueKind.kind !== exports.ValueKind.Primitive
-        ) {
-          let reason = getWriteErrorReason(valueKind);
-          functionEffect = {
-            kind:
-              valueKind.reason.size === 1 &&
-              valueKind.reason.has(ValueReason.Global)
-                ? 'GlobalMutation'
-                : 'ReactMutation',
-            error: {
-              reason: reason,
-              description:
-                place.identifier.name !== null &&
-                place.identifier.name.kind === 'named'
-                  ? `Found mutation of \`${place.identifier.name.value}\``
-                  : null,
-              loc: place.loc,
-              suggestions: null,
-              severity: exports.ErrorSeverity.InvalidReact,
-            },
-          };
-        }
         effect = exports.Effect.Mutate;
         break;
       }
       case exports.Effect.Store: {
-        if (isRefOrRefValue(place.identifier));
-        else if (valueKind.kind === exports.ValueKind.Context) {
-          functionEffect = {
-            kind: 'ContextMutation',
-            loc: place.loc,
-            effect: effectKind,
-            places:
-              valueKind.context.size === 0
-                ? new Set([place])
-                : valueKind.context,
-          };
-        } else if (
-          valueKind.kind !== exports.ValueKind.Mutable &&
-          valueKind.kind !== exports.ValueKind.Primitive
-        ) {
-          let reason = getWriteErrorReason(valueKind);
-          functionEffect = {
-            kind:
-              valueKind.reason.size === 1 &&
-              valueKind.reason.has(ValueReason.Global)
-                ? 'GlobalMutation'
-                : 'ReactMutation',
-            error: {
-              reason: reason,
-              description:
-                place.identifier.name !== null &&
-                place.identifier.name.kind === 'named'
-                  ? `Found mutation of \`${place.identifier.name.value}\``
-                  : null,
-              loc: place.loc,
-              suggestions: null,
-              severity: exports.ErrorSeverity.InvalidReact,
-            },
-          };
-        }
         effect = isObjectType(place.identifier)
           ? exports.Effect.Store
           : exports.Effect.Mutate;
@@ -162576,7 +162694,7 @@ class InferenceState {
       suggestions: null,
     });
     place.effect = effect;
-    return functionEffect;
+    return freeze;
   }
   merge(other) {
     let nextValues = null;
@@ -162831,29 +162949,31 @@ function mergeAbstractValues(a, b) {
   }
   return {kind: kind, reason: reason, context: context};
 }
-function inferBlock(env, functionEffects, state, block) {
+function inferBlock(env, state, block, functionEffects) {
   var _a, _b, _c, _d;
-  var _e;
   for (const phi of block.phis) {
     state.inferPhi(phi);
   }
   for (const instr of block.instructions) {
     const instrValue = instr.value;
-    let effect = null;
-    let lvalueEffect = exports.Effect.ConditionallyMutate;
-    let valueKind;
+    const defaultLvalueEffect = exports.Effect.ConditionallyMutate;
+    let continuation;
+    const freezeActions = [];
     switch (instrValue.kind) {
       case 'BinaryExpression': {
-        valueKind = {
-          kind: exports.ValueKind.Primitive,
-          reason: new Set([ValueReason.Other]),
-          context: new Set(),
+        continuation = {
+          kind: 'initialize',
+          valueKind: {
+            kind: exports.ValueKind.Primitive,
+            reason: new Set([ValueReason.Other]),
+            context: new Set(),
+          },
+          effect: {kind: exports.Effect.Read, reason: ValueReason.Other},
         };
-        effect = {kind: exports.Effect.Read, reason: ValueReason.Other};
         break;
       }
       case 'ArrayExpression': {
-        valueKind = hasContextRefOperand(state, instrValue)
+        const valueKind = hasContextRefOperand(state, instrValue)
           ? {
               kind: exports.ValueKind.Context,
               reason: new Set([ValueReason.Other]),
@@ -162864,37 +162984,42 @@ function inferBlock(env, functionEffects, state, block) {
               reason: new Set([ValueReason.Other]),
               context: new Set(),
             };
-        effect = {kind: exports.Effect.Capture, reason: ValueReason.Other};
-        lvalueEffect = exports.Effect.Store;
+        continuation = {
+          kind: 'initialize',
+          valueKind: valueKind,
+          effect: {kind: exports.Effect.Capture, reason: ValueReason.Other},
+          lvalueEffect: exports.Effect.Store,
+        };
         break;
       }
       case 'NewExpression': {
-        valueKind = {
+        const valueKind = {
           kind: exports.ValueKind.Mutable,
           reason: new Set([ValueReason.Other]),
           context: new Set(),
         };
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.callee,
           exports.Effect.Read,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         for (const operand of eachCallArgument(instrValue.args)) {
           state.referenceAndRecordEffects(
+            freezeActions,
             operand,
             exports.Effect.ConditionallyMutate,
-            ValueReason.Other,
-            functionEffects
+            ValueReason.Other
           );
         }
         state.initialize(instrValue, valueKind);
         state.define(instr.lvalue, instrValue);
-        instr.lvalue.effect = lvalueEffect;
-        continue;
+        instr.lvalue.effect = exports.Effect.ConditionallyMutate;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'ObjectExpression': {
-        valueKind = hasContextRefOperand(state, instrValue)
+        const valueKind = hasContextRefOperand(state, instrValue)
           ? {
               kind: exports.ValueKind.Context,
               reason: new Set([ValueReason.Other]),
@@ -162910,26 +163035,26 @@ function inferBlock(env, functionEffects, state, block) {
             case 'ObjectProperty': {
               if (property.key.kind === 'computed') {
                 state.referenceAndRecordEffects(
+                  freezeActions,
                   property.key.name,
                   exports.Effect.Freeze,
-                  ValueReason.Other,
-                  functionEffects
+                  ValueReason.Other
                 );
               }
               state.referenceAndRecordEffects(
+                freezeActions,
                 property.place,
                 exports.Effect.Capture,
-                ValueReason.Other,
-                functionEffects
+                ValueReason.Other
               );
               break;
             }
             case 'Spread': {
               state.referenceAndRecordEffects(
+                freezeActions,
                 property.place,
                 exports.Effect.Capture,
-                ValueReason.Other,
-                functionEffects
+                ValueReason.Other
               );
               break;
             }
@@ -162944,64 +163069,66 @@ function inferBlock(env, functionEffects, state, block) {
         state.initialize(instrValue, valueKind);
         state.define(instr.lvalue, instrValue);
         instr.lvalue.effect = exports.Effect.Store;
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'UnaryExpression': {
-        valueKind = {
-          kind: exports.ValueKind.Primitive,
-          reason: new Set([ValueReason.Other]),
-          context: new Set(),
+        continuation = {
+          kind: 'initialize',
+          valueKind: {
+            kind: exports.ValueKind.Primitive,
+            reason: new Set([ValueReason.Other]),
+            context: new Set(),
+          },
+          effect: {kind: exports.Effect.Read, reason: ValueReason.Other},
         };
-        effect = {kind: exports.Effect.Read, reason: ValueReason.Other};
         break;
       }
       case 'UnsupportedNode': {
-        valueKind = {
-          kind: exports.ValueKind.Mutable,
-          reason: new Set([ValueReason.Other]),
-          context: new Set(),
+        continuation = {
+          kind: 'initialize',
+          valueKind: {
+            kind: exports.ValueKind.Mutable,
+            reason: new Set([ValueReason.Other]),
+            context: new Set(),
+          },
+          effect: null,
         };
         break;
       }
       case 'JsxExpression': {
         if (instrValue.tag.kind === 'Identifier') {
           state.referenceAndRecordEffects(
+            freezeActions,
             instrValue.tag,
             exports.Effect.Freeze,
-            ValueReason.JsxCaptured,
-            functionEffects
+            ValueReason.JsxCaptured
           );
         }
         if (instrValue.children !== null) {
           for (const child of instrValue.children) {
             state.referenceAndRecordEffects(
+              freezeActions,
               child,
               exports.Effect.Freeze,
-              ValueReason.JsxCaptured,
-              functionEffects
+              ValueReason.JsxCaptured
             );
           }
         }
         for (const attr of instrValue.props) {
           if (attr.kind === 'JsxSpreadAttribute') {
             state.referenceAndRecordEffects(
+              freezeActions,
               attr.argument,
               exports.Effect.Freeze,
-              ValueReason.JsxCaptured,
-              functionEffects
+              ValueReason.JsxCaptured
             );
           } else {
-            const propEffects = [];
             state.referenceAndRecordEffects(
+              freezeActions,
               attr.place,
               exports.Effect.Freeze,
-              ValueReason.JsxCaptured,
-              propEffects
-            );
-            functionEffects.push(
-              ...propEffects.filter(
-                effect => !isEffectSafeOutsideRender(effect)
-              )
+              ValueReason.JsxCaptured
             );
           }
         }
@@ -163012,63 +163139,86 @@ function inferBlock(env, functionEffects, state, block) {
         });
         state.define(instr.lvalue, instrValue);
         instr.lvalue.effect = exports.Effect.ConditionallyMutate;
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'JsxFragment': {
-        valueKind = {
-          kind: exports.ValueKind.Frozen,
-          reason: new Set([ValueReason.Other]),
-          context: new Set(),
+        continuation = {
+          kind: 'initialize',
+          valueKind: {
+            kind: exports.ValueKind.Frozen,
+            reason: new Set([ValueReason.Other]),
+            context: new Set(),
+          },
+          effect: {kind: exports.Effect.Freeze, reason: ValueReason.Other},
         };
-        effect = {kind: exports.Effect.Freeze, reason: ValueReason.Other};
         break;
       }
       case 'TemplateLiteral': {
-        valueKind = {
-          kind: exports.ValueKind.Primitive,
-          reason: new Set([ValueReason.Other]),
-          context: new Set(),
+        continuation = {
+          kind: 'initialize',
+          valueKind: {
+            kind: exports.ValueKind.Primitive,
+            reason: new Set([ValueReason.Other]),
+            context: new Set(),
+          },
+          effect: {kind: exports.Effect.Read, reason: ValueReason.Other},
         };
-        effect = {kind: exports.Effect.Read, reason: ValueReason.Other};
         break;
       }
       case 'RegExpLiteral': {
-        valueKind = {
-          kind: exports.ValueKind.Mutable,
-          reason: new Set([ValueReason.Other]),
-          context: new Set(),
-        };
-        effect = {
-          kind: exports.Effect.ConditionallyMutate,
-          reason: ValueReason.Other,
+        continuation = {
+          kind: 'initialize',
+          valueKind: {
+            kind: exports.ValueKind.Mutable,
+            reason: new Set([ValueReason.Other]),
+            context: new Set(),
+          },
+          effect: {
+            kind: exports.Effect.ConditionallyMutate,
+            reason: ValueReason.Other,
+          },
         };
         break;
       }
       case 'MetaProperty': {
         if (instrValue.meta !== 'import' || instrValue.property !== 'meta') {
-          continue;
+          continuation = {kind: 'funeffects'};
+          break;
         }
-        valueKind = {
-          kind: exports.ValueKind.Global,
-          reason: new Set([ValueReason.Global]),
-          context: new Set(),
+        continuation = {
+          kind: 'initialize',
+          valueKind: {
+            kind: exports.ValueKind.Global,
+            reason: new Set([ValueReason.Global]),
+            context: new Set(),
+          },
+          effect: null,
         };
         break;
       }
       case 'LoadGlobal':
-        valueKind = {
-          kind: exports.ValueKind.Global,
-          reason: new Set([ValueReason.Global]),
-          context: new Set(),
+        continuation = {
+          kind: 'initialize',
+          valueKind: {
+            kind: exports.ValueKind.Global,
+            reason: new Set([ValueReason.Global]),
+            context: new Set(),
+          },
+          effect: null,
         };
         break;
       case 'Debugger':
       case 'JSXText':
       case 'Primitive': {
-        valueKind = {
-          kind: exports.ValueKind.Primitive,
-          reason: new Set([ValueReason.Other]),
-          context: new Set(),
+        continuation = {
+          kind: 'initialize',
+          valueKind: {
+            kind: exports.ValueKind.Primitive,
+            reason: new Set([ValueReason.Other]),
+            context: new Set(),
+          },
+          effect: null,
         };
         break;
       }
@@ -163077,32 +163227,16 @@ function inferBlock(env, functionEffects, state, block) {
         let hasMutableOperand = false;
         for (const operand of eachInstructionOperand(instr)) {
           state.referenceAndRecordEffects(
+            freezeActions,
             operand,
             operand.effect === exports.Effect.Unknown
               ? exports.Effect.Read
               : operand.effect,
-            ValueReason.Other,
-            []
+            ValueReason.Other
           );
           if (isMutableEffect(operand.effect, operand.loc));
           hasMutableOperand ||
             (hasMutableOperand = isMutableEffect(operand.effect, operand.loc));
-          const values = state.values(operand);
-          for (const value of values) {
-            if (
-              (value.kind === 'ObjectMethod' ||
-                value.kind === 'FunctionExpression') &&
-              value.loweredFunc.func.effects !== null
-            ) {
-              (_a = (_e = instrValue.loweredFunc.func).effects) !== null &&
-              _a !== void 0
-                ? _a
-                : (_e.effects = []);
-              instrValue.loweredFunc.func.effects.push(
-                ...value.loweredFunc.func.effects
-              );
-            }
-          }
         }
         state.initialize(instrValue, {
           kind: hasMutableOperand
@@ -163113,7 +163247,8 @@ function inferBlock(env, functionEffects, state, block) {
         });
         state.define(instr.lvalue, instrValue);
         instr.lvalue.effect = exports.Effect.Store;
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'TaggedTemplateExpression': {
         const operands = [...eachInstructionValueOperand(instrValue)];
@@ -163128,19 +163263,19 @@ function inferBlock(env, functionEffects, state, block) {
           instrValue.tag.identifier.type
         );
         let calleeEffect =
-          (_b =
+          (_a =
             signature === null || signature === void 0
               ? void 0
-              : signature.calleeEffect) !== null && _b !== void 0
-            ? _b
+              : signature.calleeEffect) !== null && _a !== void 0
+            ? _a
             : exports.Effect.ConditionallyMutate;
         const returnValueKind =
           signature !== null
             ? {
                 kind: signature.returnValueKind,
                 reason: new Set([
-                  (_c = signature.returnValueReason) !== null && _c !== void 0
-                    ? _c
+                  (_b = signature.returnValueReason) !== null && _b !== void 0
+                    ? _b
                     : ValueReason.KnownReturnSignature,
                 ]),
                 context: new Set(),
@@ -163151,15 +163286,16 @@ function inferBlock(env, functionEffects, state, block) {
                 context: new Set(),
               };
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.tag,
           calleeEffect,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         state.initialize(instrValue, returnValueKind);
         state.define(instr.lvalue, instrValue);
         instr.lvalue.effect = exports.Effect.ConditionallyMutate;
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'CallExpression': {
         const signature = getFunctionCallSignature(
@@ -163173,8 +163309,8 @@ function inferBlock(env, functionEffects, state, block) {
             ? {
                 kind: signature.returnValueKind,
                 reason: new Set([
-                  (_d = signature.returnValueReason) !== null && _d !== void 0
-                    ? _d
+                  (_c = signature.returnValueReason) !== null && _c !== void 0
+                    ? _c
                     : ValueReason.KnownReturnSignature,
                 ]),
                 context: new Set(),
@@ -163185,47 +163321,40 @@ function inferBlock(env, functionEffects, state, block) {
                 context: new Set(),
               };
         let hasCaptureArgument = false;
-        let isHook = getHookKind(env, instrValue.callee.identifier) != null;
         for (let i = 0; i < instrValue.args.length; i++) {
-          const argumentEffects = [];
           const arg = instrValue.args[i];
           const place = arg.kind === 'Identifier' ? arg : arg.place;
           if (effects !== null) {
             state.referenceAndRecordEffects(
+              freezeActions,
               place,
               effects[i],
-              ValueReason.Other,
-              argumentEffects
+              ValueReason.Other
             );
           } else {
             state.referenceAndRecordEffects(
+              freezeActions,
               place,
               exports.Effect.ConditionallyMutate,
-              ValueReason.Other,
-              argumentEffects
+              ValueReason.Other
             );
           }
-          functionEffects.push(
-            ...argumentEffects.filter(
-              argEffect => !isHook || !isEffectSafeOutsideRender(argEffect)
-            )
-          );
           hasCaptureArgument ||
             (hasCaptureArgument = place.effect === exports.Effect.Capture);
         }
         if (signature !== null) {
           state.referenceAndRecordEffects(
+            freezeActions,
             instrValue.callee,
             signature.calleeEffect,
-            ValueReason.Other,
-            functionEffects
+            ValueReason.Other
           );
         } else {
           state.referenceAndRecordEffects(
+            freezeActions,
             instrValue.callee,
             exports.Effect.ConditionallyMutate,
-            ValueReason.Other,
-            functionEffects
+            ValueReason.Other
           );
         }
         hasCaptureArgument ||
@@ -163236,7 +163365,8 @@ function inferBlock(env, functionEffects, state, block) {
         instr.lvalue.effect = hasCaptureArgument
           ? exports.Effect.Store
           : exports.Effect.ConditionallyMutate;
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'MethodCall': {
         CompilerError.invariant(state.isDefined(instrValue.receiver), {
@@ -163247,10 +163377,10 @@ function inferBlock(env, functionEffects, state, block) {
           suggestions: null,
         });
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.property,
           exports.Effect.Read,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         const signature = getFunctionCallSignature(
           env,
@@ -163276,17 +163406,17 @@ function inferBlock(env, functionEffects, state, block) {
           for (const arg of instrValue.args) {
             const place = arg.kind === 'Identifier' ? arg : arg.place;
             state.referenceAndRecordEffects(
+              freezeActions,
               place,
               exports.Effect.Read,
-              ValueReason.Other,
-              functionEffects
+              ValueReason.Other
             );
           }
           state.referenceAndRecordEffects(
+            freezeActions,
             instrValue.receiver,
             exports.Effect.Capture,
-            ValueReason.Other,
-            functionEffects
+            ValueReason.Other
           );
           state.initialize(instrValue, returnValueKind);
           state.define(instr.lvalue, instrValue);
@@ -163294,52 +163424,46 @@ function inferBlock(env, functionEffects, state, block) {
             instrValue.receiver.effect === exports.Effect.Capture
               ? exports.Effect.Store
               : exports.Effect.ConditionallyMutate;
-          continue;
+          continuation = {kind: 'funeffects'};
+          break;
         }
         const effects =
           signature !== null ? getFunctionEffects(instrValue, signature) : null;
         let hasCaptureArgument = false;
-        let isHook = getHookKind(env, instrValue.property.identifier) != null;
         for (let i = 0; i < instrValue.args.length; i++) {
-          const argumentEffects = [];
           const arg = instrValue.args[i];
           const place = arg.kind === 'Identifier' ? arg : arg.place;
           if (effects !== null) {
             state.referenceAndRecordEffects(
+              freezeActions,
               place,
               effects[i],
-              ValueReason.Other,
-              argumentEffects
+              ValueReason.Other
             );
           } else {
             state.referenceAndRecordEffects(
+              freezeActions,
               place,
               exports.Effect.ConditionallyMutate,
-              ValueReason.Other,
-              argumentEffects
+              ValueReason.Other
             );
           }
-          functionEffects.push(
-            ...argumentEffects.filter(
-              argEffect => !isHook || !isEffectSafeOutsideRender(argEffect)
-            )
-          );
           hasCaptureArgument ||
             (hasCaptureArgument = place.effect === exports.Effect.Capture);
         }
         if (signature !== null) {
           state.referenceAndRecordEffects(
+            freezeActions,
             instrValue.receiver,
             signature.calleeEffect,
-            ValueReason.Other,
-            functionEffects
+            ValueReason.Other
           );
         } else {
           state.referenceAndRecordEffects(
+            freezeActions,
             instrValue.receiver,
             exports.Effect.ConditionallyMutate,
-            ValueReason.Other,
-            functionEffects
+            ValueReason.Other
           );
         }
         hasCaptureArgument ||
@@ -163350,7 +163474,8 @@ function inferBlock(env, functionEffects, state, block) {
         instr.lvalue.effect = hasCaptureArgument
           ? exports.Effect.Store
           : exports.Effect.ConditionallyMutate;
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'PropertyStore': {
         const effect =
@@ -163358,43 +163483,48 @@ function inferBlock(env, functionEffects, state, block) {
             ? exports.Effect.ConditionallyMutate
             : exports.Effect.Capture;
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.value,
           effect,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.object,
           exports.Effect.Store,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         const lvalue = instr.lvalue;
         state.alias(lvalue, instrValue.value);
         lvalue.effect = exports.Effect.Store;
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'PropertyDelete': {
-        valueKind = {
-          kind: exports.ValueKind.Primitive,
-          reason: new Set([ValueReason.Other]),
-          context: new Set(),
+        continuation = {
+          kind: 'initialize',
+          valueKind: {
+            kind: exports.ValueKind.Primitive,
+            reason: new Set([ValueReason.Other]),
+            context: new Set(),
+          },
+          effect: {kind: exports.Effect.Mutate, reason: ValueReason.Other},
         };
-        effect = {kind: exports.Effect.Mutate, reason: ValueReason.Other};
         break;
       }
       case 'PropertyLoad': {
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.object,
           exports.Effect.Read,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         const lvalue = instr.lvalue;
         lvalue.effect = exports.Effect.ConditionallyMutate;
         state.initialize(instrValue, state.kind(instrValue.object));
         state.define(lvalue, instrValue);
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'ComputedStore': {
         const effect =
@@ -163402,40 +163532,41 @@ function inferBlock(env, functionEffects, state, block) {
             ? exports.Effect.ConditionallyMutate
             : exports.Effect.Capture;
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.value,
           effect,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.property,
           exports.Effect.Capture,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.object,
           exports.Effect.Store,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         const lvalue = instr.lvalue;
         state.alias(lvalue, instrValue.value);
         lvalue.effect = exports.Effect.Store;
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'ComputedDelete': {
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.object,
           exports.Effect.Mutate,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.property,
           exports.Effect.Read,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         state.initialize(instrValue, {
           kind: exports.ValueKind.Primitive,
@@ -163444,69 +163575,73 @@ function inferBlock(env, functionEffects, state, block) {
         });
         state.define(instr.lvalue, instrValue);
         instr.lvalue.effect = exports.Effect.Mutate;
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'ComputedLoad': {
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.object,
           exports.Effect.Read,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.property,
           exports.Effect.Read,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         const lvalue = instr.lvalue;
         lvalue.effect = exports.Effect.ConditionallyMutate;
         state.initialize(instrValue, state.kind(instrValue.object));
         state.define(lvalue, instrValue);
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'Await': {
         state.initialize(instrValue, state.kind(instrValue.value));
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.value,
           exports.Effect.ConditionallyMutate,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         const lvalue = instr.lvalue;
         lvalue.effect = exports.Effect.ConditionallyMutate;
         state.alias(lvalue, instrValue.value);
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'TypeCastExpression': {
         state.initialize(instrValue, state.kind(instrValue.value));
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.value,
           exports.Effect.Read,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         const lvalue = instr.lvalue;
         lvalue.effect = exports.Effect.ConditionallyMutate;
         state.alias(lvalue, instrValue.value);
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'StartMemoize':
       case 'FinishMemoize': {
         for (const val of eachInstructionValueOperand(instrValue)) {
           if (env.config.enablePreserveExistingMemoizationGuarantees) {
             state.referenceAndRecordEffects(
+              freezeActions,
               val,
               exports.Effect.Freeze,
-              ValueReason.Other,
-              []
+              ValueReason.Other
             );
           } else {
             state.referenceAndRecordEffects(
+              freezeActions,
               val,
               exports.Effect.Read,
-              ValueReason.Other,
-              []
+              ValueReason.Other
             );
           }
         }
@@ -163518,7 +163653,8 @@ function inferBlock(env, functionEffects, state, block) {
           context: new Set(),
         });
         state.define(lvalue, instrValue);
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'LoadLocal': {
         const lvalue = instr.lvalue;
@@ -163528,28 +163664,30 @@ function inferBlock(env, functionEffects, state, block) {
             ? exports.Effect.ConditionallyMutate
             : exports.Effect.Capture;
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.place,
           effect,
-          ValueReason.Other,
-          []
+          ValueReason.Other
         );
         lvalue.effect = exports.Effect.ConditionallyMutate;
         state.alias(lvalue, instrValue.place);
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'LoadContext': {
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.place,
           exports.Effect.Capture,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         const lvalue = instr.lvalue;
         lvalue.effect = exports.Effect.ConditionallyMutate;
         const valueKind = state.kind(instrValue.place);
         state.initialize(instrValue, valueKind);
         state.define(lvalue, instrValue);
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'DeclareLocal': {
         const value = UndefinedValue;
@@ -163568,7 +163706,8 @@ function inferBlock(env, functionEffects, state, block) {
               }
         );
         state.define(instrValue.lvalue.place, value);
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'DeclareContext': {
         state.initialize(instrValue, {
@@ -163577,7 +163716,8 @@ function inferBlock(env, functionEffects, state, block) {
           context: new Set(),
         });
         state.define(instrValue.lvalue.place, instrValue);
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'PostfixUpdate':
       case 'PrefixUpdate': {
@@ -163587,17 +163727,18 @@ function inferBlock(env, functionEffects, state, block) {
             ? exports.Effect.ConditionallyMutate
             : exports.Effect.Capture;
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.value,
           effect,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         const lvalue = instr.lvalue;
         state.alias(lvalue, instrValue.value);
         lvalue.effect = exports.Effect.Store;
         state.alias(instrValue.lvalue, instrValue.value);
         instrValue.lvalue.effect = exports.Effect.Store;
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'StoreLocal': {
         const effect =
@@ -163606,56 +163747,49 @@ function inferBlock(env, functionEffects, state, block) {
             ? exports.Effect.ConditionallyMutate
             : exports.Effect.Capture;
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.value,
           effect,
-          ValueReason.Other,
-          []
+          ValueReason.Other
         );
         const lvalue = instr.lvalue;
         state.alias(lvalue, instrValue.value);
         lvalue.effect = exports.Effect.Store;
         state.alias(instrValue.lvalue.place, instrValue.value);
         instrValue.lvalue.place.effect = exports.Effect.Store;
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'StoreContext': {
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.value,
           exports.Effect.ConditionallyMutate,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.lvalue.place,
           exports.Effect.Mutate,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         const lvalue = instr.lvalue;
         state.alias(lvalue, instrValue.value);
         lvalue.effect = exports.Effect.Store;
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'StoreGlobal': {
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.value,
           exports.Effect.Capture,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         const lvalue = instr.lvalue;
         lvalue.effect = exports.Effect.Store;
-        functionEffects.push({
-          kind: 'GlobalMutation',
-          error: {
-            reason:
-              'Unexpected reassignment of a variable which was defined outside of the component. Components and hooks should be pure and side-effect free, but variable reassignment is a form of side-effect. If this variable is used in rendering, use useState instead. (https://react.dev/reference/rules/components-and-hooks-must-be-pure#side-effects-must-run-outside-of-render)',
-            loc: instr.loc,
-            suggestions: null,
-            severity: exports.ErrorSeverity.InvalidReact,
-          },
-        });
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'Destructure': {
         let effect = exports.Effect.Capture;
@@ -163669,10 +163803,10 @@ function inferBlock(env, functionEffects, state, block) {
           }
         }
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.value,
           effect,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         const lvalue = instr.lvalue;
         state.alias(lvalue, instrValue.value);
@@ -163681,13 +163815,16 @@ function inferBlock(env, functionEffects, state, block) {
           state.alias(place, instrValue.value);
           place.effect = exports.Effect.Store;
         }
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'GetIterator': {
         const kind = state.kind(instrValue.collection).kind;
         const isMutable =
           kind === exports.ValueKind.Mutable ||
           kind === exports.ValueKind.Context;
+        let effect;
+        let valueKind;
         if (!isMutable || isArrayType(instrValue.collection.identifier)) {
           effect = {kind: exports.Effect.Read, reason: ValueReason.Other};
           valueKind = {
@@ -163699,34 +163836,43 @@ function inferBlock(env, functionEffects, state, block) {
           effect = {kind: exports.Effect.Capture, reason: ValueReason.Other};
           valueKind = state.kind(instrValue.collection);
         }
-        lvalueEffect = exports.Effect.Store;
+        continuation = {
+          kind: 'initialize',
+          effect: effect,
+          valueKind: valueKind,
+          lvalueEffect: exports.Effect.Store,
+        };
         break;
       }
       case 'IteratorNext': {
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.iterator,
           exports.Effect.ConditionallyMutate,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         state.referenceAndRecordEffects(
+          freezeActions,
           instrValue.collection,
           exports.Effect.Capture,
-          ValueReason.Other,
-          functionEffects
+          ValueReason.Other
         );
         state.initialize(instrValue, state.kind(instrValue.collection));
         state.define(instr.lvalue, instrValue);
         instr.lvalue.effect = exports.Effect.Store;
-        continue;
+        continuation = {kind: 'funeffects'};
+        break;
       }
       case 'NextPropertyOf': {
-        effect = {kind: exports.Effect.Read, reason: ValueReason.Other};
-        lvalueEffect = exports.Effect.Store;
-        valueKind = {
-          kind: exports.ValueKind.Primitive,
-          reason: new Set([ValueReason.Other]),
-          context: new Set(),
+        continuation = {
+          kind: 'initialize',
+          effect: {kind: exports.Effect.Read, reason: ValueReason.Other},
+          lvalueEffect: exports.Effect.Store,
+          valueKind: {
+            kind: exports.ValueKind.Primitive,
+            reason: new Set([ValueReason.Other]),
+            context: new Set(),
+          },
         };
         break;
       }
@@ -163734,24 +163880,34 @@ function inferBlock(env, functionEffects, state, block) {
         assertExhaustive(instrValue, 'Unexpected instruction kind');
       }
     }
-    for (const operand of eachInstructionOperand(instr)) {
-      CompilerError.invariant(effect != null, {
-        reason: `effectKind must be set for instruction value \`${instrValue.kind}\``,
-        description: null,
-        loc: instrValue.loc,
-        suggestions: null,
-      });
-      state.referenceAndRecordEffects(
-        operand,
-        effect.kind,
-        effect.reason,
-        functionEffects
-      );
-    }
-    state.initialize(instrValue, valueKind);
-    state.define(instr.lvalue, instrValue);
-    instr.lvalue.effect = lvalueEffect;
+    if (continuation.kind === 'initialize') {
+      for (const operand of eachInstructionOperand(instr)) {
+        CompilerError.invariant(continuation.effect != null, {
+          reason: `effectKind must be set for instruction value \`${instrValue.kind}\``,
+          description: null,
+          loc: instrValue.loc,
+          suggestions: null,
+        });
+        state.referenceAndRecordEffects(
+          freezeActions,
+          operand,
+          continuation.effect.kind,
+          continuation.effect.reason
+        );
+      }
+      state.initialize(instrValue, continuation.valueKind);
+      state.define(instr.lvalue, instrValue);
+      instr.lvalue.effect =
+        (_d = continuation.lvalueEffect) !== null && _d !== void 0
+          ? _d
+          : defaultLvalueEffect;
+    }
+    functionEffects.push(...inferInstructionFunctionEffects(env, state, instr));
+    freezeActions.forEach(({values: values, reason: reason}) =>
+      state.freezeValues(values, reason)
+    );
   }
+  const terminalFreezeActions = [];
   for (const operand of eachTerminalOperand(block.terminal)) {
     let effect;
     if (block.terminal.kind === 'return' || block.terminal.kind === 'throw') {
@@ -163766,17 +163922,17 @@ function inferBlock(env, functionEffects, state, block) {
     } else {
       effect = exports.Effect.Read;
     }
-    const propEffects = [];
     state.referenceAndRecordEffects(
+      terminalFreezeActions,
       operand,
       effect,
-      ValueReason.Other,
-      propEffects
-    );
-    functionEffects.push(
-      ...propEffects.filter(effect => !isEffectSafeOutsideRender(effect))
+      ValueReason.Other
     );
   }
+  functionEffects.push(...inferTerminalFunctionEffects(state, block));
+  terminalFreezeActions.forEach(({values: values, reason: reason}) =>
+    state.freezeValues(values, reason)
+  );
 }
 function hasContextRefOperand(state, instrValue) {
   for (const place of eachInstructionValueOperand(instrValue)) {
@@ -163843,28 +163999,6 @@ function areArgumentsImmutableAndNonMutating(state, args) {
   }
   return true;
 }
-function isEffectSafeOutsideRender(effect) {
-  return effect.kind === 'GlobalMutation';
-}
-function getWriteErrorReason(abstractValue) {
-  if (abstractValue.reason.has(ValueReason.Global)) {
-    return 'Writing to a variable defined outside a component or hook is not allowed. Consider using an effect';
-  } else if (abstractValue.reason.has(ValueReason.JsxCaptured)) {
-    return 'Updating a value used previously in JSX is not allowed. Consider moving the mutation before the JSX';
-  } else if (abstractValue.reason.has(ValueReason.Context)) {
-    return `Mutating a value returned from 'useContext()', which should not be mutated`;
-  } else if (abstractValue.reason.has(ValueReason.KnownReturnSignature)) {
-    return 'Mutating a value returned from a function whose return value should not be mutated';
-  } else if (abstractValue.reason.has(ValueReason.ReactiveFunctionArgument)) {
-    return 'Mutating component props or hook arguments is not allowed. Consider using a local variable instead';
-  } else if (abstractValue.reason.has(ValueReason.State)) {
-    return "Mutating a value returned from 'useState()', which should not be mutated. Use the setter function to update instead";
-  } else if (abstractValue.reason.has(ValueReason.ReducerState)) {
-    return "Mutating a value returned from 'useReducer()', which should not be mutated. Use the dispatch function to update instead";
-  } else {
-    return 'This mutates a variable that React considers immutable';
-  }
-}
 function pruneNonEscapingScopes(fn) {
   const state = new State(fn.env);
   for (const param of fn.params) {