validateEffect() — react Function Reference

Source Code

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoDerivedComputationsInEffects_exp.ts lines 631–842

function validateEffect(
  effectFunction: HIRFunction,
  dependencies: ArrayExpression,
  context: ValidationContext,
): void {
  const seenBlocks: Set<BlockId> = new Set();

  const effectDerivedSetStateCalls: Array<{
    value: CallExpression;
    id: IdentifierId;
    sourceIds: Set<IdentifierId>;
    typeOfValue: TypeOfValue;
  }> = [];

  const effectSetStateUsages: Map<
    IdentifierId,
    Set<SourceLocation>
  > = new Map();

  // Consider setStates in the effect's dependency array as being part of effectSetStateUsages
  for (const dep of dependencies.elements) {
    if (dep.kind === 'Identifier') {
      const root = getRootSetState(dep.identifier.id, context.setStateLoads);
      if (root !== null) {
        effectSetStateUsages.set(root, new Set([dep.loc]));
      }
    }
  }

  let cleanUpFunctionDeps: Set<IdentifierId> | undefined;

  const globals: Set<IdentifierId> = new Set();
  for (const block of effectFunction.body.blocks.values()) {
    /*
     * if the block is in an effect and is of type return then its an effect's cleanup function
     * if the cleanup function depends on a value from which effect-set state is derived then
     * we can't validate
     */
    if (
      block.terminal.kind === 'return' &&
      block.terminal.returnVariant === 'Explicit'
    ) {
      cleanUpFunctionDeps = getFnLocalDeps(
        context.functions.get(block.terminal.value.identifier.id),
      );
    }
    for (const pred of block.preds) {
      if (!seenBlocks.has(pred)) {
        // skip if block has a back edge
        return;
      }
    }

    for (const instr of block.instructions) {
      // Early return if any instruction is deriving a value from a ref
      if (isUseRefType(instr.lvalue.identifier)) {
        return;
      }

      maybeRecordSetState(instr, context.setStateLoads, effectSetStateUsages);

      for (const operand of eachInstructionOperand(instr)) {
        if (context.setStateLoads.has(operand.identifier.id)) {
          const rootSetStateId = getRootSetState(
            operand.identifier.id,
            context.setStateLoads,
          );
          if (rootSetStateId !== null) {
            effectSetStateUsages.get(rootSetStateId)?.add(operand.loc);
          }
        }
      }

      if (
        instr.value.kind === 'CallExpression' &&
        isSetStateType(instr.value.callee.identifier) &&
        instr.value.args.length === 1 &&
        instr.value.args[0].kind === 'Identifier'
      ) {
        const calleeMetadata = context.derivationCache.cache.get(
          instr.value.callee.identifier.id,