validateNoDerivedComputationsInEffects_exp() — react Function Reference

Source Code

compiler/packages/babel-plugin-react-compiler/src/Validation/ValidateNoDerivedComputationsInEffects_exp.ts lines 183–256

export function validateNoDerivedComputationsInEffects_exp(
  fn: HIRFunction,
): Result<void, CompilerError> {
  const functions: Map<IdentifierId, FunctionExpression> = new Map();
  const candidateDependencies: Map<IdentifierId, ArrayExpression> = new Map();
  const derivationCache = new DerivationCache();
  const errors = new CompilerError();
  const effectsCache: Map<IdentifierId, EffectMetadata> = new Map();

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

  const context: ValidationContext = {
    functions,
    candidateDependencies,
    errors,
    derivationCache,
    effectsCache,
    setStateLoads,
    setStateUsages,
  };

  if (fn.fnType === 'Hook') {
    for (const param of fn.params) {
      if (param.kind === 'Identifier') {
        context.derivationCache.cache.set(param.identifier.id, {
          place: param,
          sourcesIds: new Set(),
          typeOfValue: 'fromProps',
          isStateSource: true,
        });
      }
    }
  } else if (fn.fnType === 'Component') {
    const props = fn.params[0];
    if (props != null && props.kind === 'Identifier') {
      context.derivationCache.cache.set(props.identifier.id, {
        place: props,
        sourcesIds: new Set(),
        typeOfValue: 'fromProps',
        isStateSource: true,
      });
    }
  }

  let isFirstPass = true;
  let iterationCount = 0;
  do {
    context.derivationCache.takeSnapshot();

    for (const block of fn.body.blocks.values()) {
      recordPhiDerivations(block, context);
      for (const instr of block.instructions) {
        recordInstructionDerivations(instr, context, isFirstPass);
      }
    }

    context.derivationCache.checkForChanges();
    isFirstPass = false;
    iterationCount++;
    CompilerError.invariant(iterationCount < MAX_FIXPOINT_ITERATIONS, {
      reason:
        '[ValidateNoDerivedComputationsInEffects] Fixpoint iteration failed to converge.',
      description: `Fixpoint iteration exceeded ${MAX_FIXPOINT_ITERATIONS} iterations while tracking derivations. This suggests a cyclic dependency in the derivation cache.`,
      loc: fn.loc,
    });
  } while (context.derivationCache.snapshot());

  for (const [, effect] of effectsCache) {
    validateEffect(effect.effect, effect.dependencies, context);
  }

  return errors.asResult();
}